code stringlengths 52 7.75k | docs stringlengths 1 5.85k |
|---|---|
def delete(self):
self.requester.delete(
'/{endpoint}/{id}', endpoint=self.endpoint,
id=self.id
)
return self | Delete the current :class:`InstanceResource` |
def to_dict(self):
self_dict = {}
for key, value in six.iteritems(self.__dict__):
if self.allowed_params and key in self.allowed_params:
self_dict[key] = value
return self_dict | Get a dictionary representation of :class:`InstanceResource` |
def parse(cls, requester, entry):
if not type(entry) is dict:
return entry
for key_to_parse, cls_to_parse in six.iteritems(cls.parser):
if key_to_parse in entry:
entry[key_to_parse] = cls_to_parse.parse(
requester, entry[key_to_parse]
... | Turns a JSON object into a model instance. |
def set_attribute(self, id, value, version=1):
attributes = self._get_attributes(cache=True)
formatted_id = '{0}'.format(id)
attributes['attributes_values'][formatted_id] = value
response = self.requester.patch(
'/{endpoint}/custom-attributes-values/{id}',
... | Set attribute to a specific value
:param id: id of the attribute
:param value: value of the attribute
:param version: version of the attribute (default = 1) |
def create(self, project, name, **attrs):
attrs.update(
{
'project': project, 'name': name
}
)
return self._new_resource(payload=attrs) | Create a new :class:`CustomAttribute`.
:param project: :class:`Project` id
:param name: name of the custom attribute
:param attrs: optional attributes of the custom attributes |
def starred_projects(self):
response = self.requester.get(
'/{endpoint}/{id}/starred', endpoint=self.endpoint,
id=self.id
)
return Projects.parse(self.requester, response.json()) | Get a list of starred :class:`Project`. |
def create(self, project, email, role, **attrs):
attrs.update({'project': project, 'email': email, 'role': role})
return self._new_resource(payload=attrs) | Create a new :class:`Membership`.
:param project: :class:`Project` id
:param email: email of the :class:`Membership`
:param role: role of the :class:`Membership`
:param attrs: optional attributes of the :class:`Membership` |
def create(self, project, object_id, attached_file, **attrs):
attrs.update({'project': project, 'object_id': object_id})
if isinstance(attached_file, file):
attachment = attached_file
elif isinstance(attached_file, six.string_types):
try:
attachm... | Create a new :class:`Attachment`.
:param project: :class:`Project` id
:param object_id: id of the current object
:param ref: :class:`Task` reference
:param attached_file: file path that you want to upload
:param attrs: optional attributes for the :class:`Attachment` |
def add_task(self, subject, status, **attrs):
return Tasks(self.requester).create(
self.project, subject, status,
user_story=self.id, **attrs
) | Add a :class:`Task` to the current :class:`UserStory` and return it.
:param subject: subject of the :class:`Task`
:param status: status of the :class:`Task`
:param attrs: optional attributes for :class:`Task` |
def create(self, project, subject, **attrs):
attrs.update({'project': project, 'subject': subject})
return self._new_resource(payload=attrs) | Create a new :class:`UserStory`.
:param project: :class:`Project` id
:param subject: subject of the :class:`UserStory`
:param attrs: optional attributes of the :class:`UserStory` |
def stats(self):
response = self.requester.get(
'/{endpoint}/{id}/stats',
endpoint=self.endpoint, id=self.id
)
return response.json() | Get the stats for the current :class:`Milestone` |
def create(self, project, name, estimated_start,
estimated_finish, **attrs):
if isinstance(estimated_start, datetime.datetime):
estimated_start = estimated_start.strftime('%Y-%m-%d')
if isinstance(estimated_finish, datetime.datetime):
estimated_finish = es... | Create a new :class:`Milestone`.
:param project: :class:`Project` id
:param name: name of the :class:`Milestone`
:param estimated_start: est. start time of the :class:`Milestone`
:param estimated_finish: est. finish time of the :class:`Milestone`
:param attrs: optional attribute... |
def attach(self, attached_file, **attrs):
return TaskAttachments(self.requester).create(
self.project, self.id,
attached_file, **attrs
) | Attach a file to the :class:`Task`
:param attached_file: file path to attach
:param attrs: optional attributes for the attached file |
def upvote(self):
self.requester.post(
'/{endpoint}/{id}/upvote',
endpoint=self.endpoint, id=self.id
)
return self | Upvote :class:`Issue`. |
def downvote(self):
self.requester.post(
'/{endpoint}/{id}/downvote',
endpoint=self.endpoint, id=self.id
)
return self | Downvote :class:`Issue`. |
def create(self, project, subject, priority, status,
issue_type, severity, **attrs):
attrs.update(
{
'project': project, 'subject': subject,
'priority': priority, 'status': status,
'type': issue_type, 'severity': severity
... | Create a new :class:`Task`.
:param project: :class:`Project` id
:param subject: subject of the :class:`Issue`
:param priority: priority of the :class:`Issue`
:param status: status of the :class:`Issue`
:param issue_type: Issue type of the :class:`Issue`
:param severity: ... |
def get_task_by_ref(self, ref):
response = self.requester.get(
'/{endpoint}/by_ref?ref={task_ref}&project={project_id}',
endpoint=Task.endpoint,
task_ref=ref,
project_id=self.id
)
return Task.parse(self.requester, response.json()) | Get a :class:`Task` by ref.
:param ref: :class:`Task` reference |
def get_userstory_by_ref(self, ref):
response = self.requester.get(
'/{endpoint}/by_ref?ref={us_ref}&project={project_id}',
endpoint=UserStory.endpoint,
us_ref=ref,
project_id=self.id
)
return UserStory.parse(self.requester, response.json(... | Get a :class:`UserStory` by ref.
:param ref: :class:`UserStory` reference |
def get_issue_by_ref(self, ref):
response = self.requester.get(
'/{endpoint}/by_ref?ref={us_ref}&project={project_id}',
endpoint=Issue.endpoint,
us_ref=ref,
project_id=self.id
)
return Issue.parse(self.requester, response.json()) | Get a :class:`Issue` by ref.
:param ref: :class:`Issue` reference |
def issues_stats(self):
response = self.requester.get(
'/{endpoint}/{id}/issues_stats',
endpoint=self.endpoint, id=self.id
)
return response.json() | Get stats for issues of the project |
def like(self):
self.requester.post(
'/{endpoint}/{id}/like',
endpoint=self.endpoint, id=self.id
)
return self | Like the project |
def unlike(self):
self.requester.post(
'/{endpoint}/{id}/unlike',
endpoint=self.endpoint, id=self.id
)
return self | Unlike the project |
def star(self):
warnings.warn(
"Deprecated! Update Taiga and use .like() instead",
DeprecationWarning
)
self.requester.post(
'/{endpoint}/{id}/star',
endpoint=self.endpoint, id=self.id
)
return self | Stars the project
.. deprecated:: 0.8.5
Update Taiga and use like instead |
def add_membership(self, email, role, **attrs):
return Memberships(self.requester).create(
self.id, email, role, **attrs
) | Add a Membership to the project and returns a
:class:`Membership` resource.
:param email: email for :class:`Membership`
:param role: role for :class:`Membership`
:param attrs: role for :class:`Membership`
:param attrs: optional :class:`Membership` attributes |
def add_user_story(self, subject, **attrs):
return UserStories(self.requester).create(
self.id, subject, **attrs
) | Adds a :class:`UserStory` and returns a :class:`UserStory` resource.
:param subject: subject of the :class:`UserStory`
:param attrs: other :class:`UserStory` attributes |
def import_user_story(self, subject, status, **attrs):
return UserStories(self.requester).import_(
self.id, subject, status, **attrs
) | Import an user story and returns a :class:`UserStory` resource.
:param subject: subject of the :class:`UserStory`
:param status: status of the :class:`UserStory`
:param attrs: optional :class:`UserStory` attributes |
def add_issue(self, subject, priority, status,
issue_type, severity, **attrs):
return Issues(self.requester).create(
self.id, subject, priority, status,
issue_type, severity, **attrs
) | Adds a Issue and returns a :class:`Issue` resource.
:param subject: subject of the :class:`Issue`
:param priority: priority of the :class:`Issue`
:param priority: status of the :class:`Issue`
:param issue_type: type of the :class:`Issue`
:param severity: severity of the :class:`... |
def import_issue(self, subject, priority, status,
issue_type, severity, **attrs):
return Issues(self.requester).import_(
self.id, subject, priority, status,
issue_type, severity, **attrs
) | Import and issue and returns a :class:`Issue` resource.
:param subject: subject of :class:`Issue`
:param priority: priority of :class:`Issue`
:param status: status of :class:`Issue`
:param issue_type: issue type of :class:`Issue`
:param severity: severity of :class:`Issue`
... |
def add_milestone(self, name, estimated_start, estimated_finish, **attrs):
return Milestones(self.requester).create(
self.id, name, estimated_start,
estimated_finish, **attrs
) | Add a Milestone to the project and returns a :class:`Milestone` object.
:param name: name of the :class:`Milestone`
:param estimated_start: estimated start time of the
:class:`Milestone`
:param estimated_finish: estimated finish time of the
... |
def import_milestone(self, name, estimated_start, estimated_finish,
**attrs):
return Milestones(self.requester).import_(
self.id, name, estimated_start,
estimated_finish, **attrs
) | Import a Milestone and returns a :class:`Milestone` object.
:param name: name of the :class:`Milestone`
:param estimated_start: estimated start time of the
:class:`Milestone`
:param estimated_finish: estimated finish time of the
:... |
def list_milestones(self, **queryparams):
return Milestones(self.requester).list(project=self.id, **queryparams) | Get the list of :class:`Milestone` resources for the project. |
def add_point(self, name, value, **attrs):
return Points(self.requester).create(self.id, name, value, **attrs) | Add a Point to the project and returns a :class:`Point` object.
:param name: name of the :class:`Point`
:param value: value of the :class:`Point`
:param attrs: optional attributes for :class:`Point` |
def add_task_status(self, name, **attrs):
return TaskStatuses(self.requester).create(self.id, name, **attrs) | Add a Task status to the project and returns a
:class:`TaskStatus` object.
:param name: name of the :class:`TaskStatus`
:param attrs: optional attributes for :class:`TaskStatus` |
def import_task(self, subject, status, **attrs):
return Tasks(self.requester).import_(
self.id, subject, status, **attrs
) | Import a Task and return a :class:`Task` object.
:param subject: subject of the :class:`Task`
:param status: status of the :class:`Task`
:param attrs: optional attributes for :class:`Task` |
def add_user_story_status(self, name, **attrs):
return UserStoryStatuses(self.requester).create(self.id, name, **attrs) | Add a UserStory status to the project and returns a
:class:`UserStoryStatus` object.
:param name: name of the :class:`UserStoryStatus`
:param attrs: optional attributes for :class:`UserStoryStatus` |
def add_issue_type(self, name, **attrs):
return IssueTypes(self.requester).create(self.id, name, **attrs) | Add a Issue type to the project and returns a
:class:`IssueType` object.
:param name: name of the :class:`IssueType`
:param attrs: optional attributes for :class:`IssueType` |
def add_severity(self, name, **attrs):
return Severities(self.requester).create(self.id, name, **attrs) | Add a Severity to the project and returns a :class:`Severity` object.
:param name: name of the :class:`Severity`
:param attrs: optional attributes for :class:`Severity` |
def add_role(self, name, **attrs):
return Roles(self.requester).create(self.id, name, **attrs) | Add a Role to the project and returns a :class:`Role` object.
:param name: name of the :class:`Role`
:param attrs: optional attributes for :class:`Role` |
def add_priority(self, name, **attrs):
return Priorities(self.requester).create(self.id, name, **attrs) | Add a Priority to the project and returns a :class:`Priority` object.
:param name: name of the :class:`Priority`
:param attrs: optional attributes for :class:`Priority` |
def add_issue_status(self, name, **attrs):
return IssueStatuses(self.requester).create(self.id, name, **attrs) | Add a Issue status to the project and returns a
:class:`IssueStatus` object.
:param name: name of the :class:`IssueStatus`
:param attrs: optional attributes for :class:`IssueStatus` |
def add_wikipage(self, slug, content, **attrs):
return WikiPages(self.requester).create(
self.id, slug, content, **attrs
) | Add a Wiki page to the project and returns a :class:`WikiPage` object.
:param name: name of the :class:`WikiPage`
:param attrs: optional attributes for :class:`WikiPage` |
def import_wikipage(self, slug, content, **attrs):
return WikiPages(self.requester).import_(
self.id, slug, content, **attrs
) | Import a Wiki page and return a :class:`WikiPage` object.
:param slug: slug of the :class:`WikiPage`
:param content: content of the :class:`WikiPage`
:param attrs: optional attributes for :class:`Task` |
def add_wikilink(self, title, href, **attrs):
return WikiLinks(self.requester).create(self.id, title, href, **attrs) | Add a Wiki link to the project and returns a :class:`WikiLink` object.
:param title: title of the :class:`WikiLink`
:param href: href of the :class:`WikiLink`
:param attrs: optional attributes for :class:`WikiLink` |
def import_wikilink(self, title, href, **attrs):
return WikiLinks(self.requester).import_(self.id, title, href, **attrs) | Import a Wiki link and return a :class:`WikiLink` object.
:param title: title of the :class:`WikiLink`
:param href: href of the :class:`WikiLink`
:param attrs: optional attributes for :class:`WikiLink` |
def add_issue_attribute(self, name, **attrs):
return IssueAttributes(self.requester).create(
self.id, name, **attrs
) | Add a new Issue attribute and return a :class:`IssueAttribute` object.
:param name: name of the :class:`IssueAttribute`
:param attrs: optional attributes for :class:`IssueAttribute` |
def add_task_attribute(self, name, **attrs):
return TaskAttributes(self.requester).create(
self.id, name, **attrs
) | Add a new Task attribute and return a :class:`TaskAttribute` object.
:param name: name of the :class:`TaskAttribute`
:param attrs: optional attributes for :class:`TaskAttribute` |
def add_user_story_attribute(self, name, **attrs):
return UserStoryAttributes(self.requester).create(
self.id, name, **attrs
) | Add a new User Story attribute and return a
:class:`UserStoryAttribute` object.
:param name: name of the :class:`UserStoryAttribute`
:param attrs: optional attributes for :class:`UserStoryAttribute` |
def add_webhook(self, name, url, key, **attrs):
return Webhooks(self.requester).create(
self.id, name, url, key, **attrs
) | Add a new Webhook and return a :class:`Webhook` object.
:param name: name of the :class:`Webhook`
:param url: payload url of the :class:`Webhook`
:param key: secret key of the :class:`Webhook`
:param attrs: optional attributes for :class:`Webhook` |
def create(self, name, description, **attrs):
attrs.update({'name': name, 'description': description})
return self._new_resource(payload=attrs) | Create a new :class:`Project`
:param name: name of the :class:`Project`
:param description: description of the :class:`Project`
:param attrs: optional attributes for :class:`Project` |
def get_by_slug(self, slug):
response = self.requester.get(
'/{endpoint}/by_slug?slug={slug}',
endpoint=self.instance.endpoint,
slug=slug
)
return self.instance.parse(self.requester, response.json()) | Get a :class:`Project` by slug
:param slug: the slug of the :class:`Project` |
def create(self, project, slug, content, **attrs):
attrs.update({'project': project, 'slug': slug, 'content': content})
return self._new_resource(payload=attrs) | create a new :class:`WikiPage`
:param project: :class:`Project` id
:param slug: slug of the wiki page
:param content: content of the wiki page
:param attrs: optional attributes for the :class:`WikiPage` |
def create(self, project, title, href, **attrs):
attrs.update({'project': project, 'title': title, 'href': href})
return self._new_resource(payload=attrs) | Create a new :class:`WikiLink`
:param project: :class:`Project` id
:param title: title of the wiki link
:param href: href for the wiki link
:param attrs: optional attributes for the :class:`WikiLink` |
def get(self, resource_id):
response = self.requester.get(
'/{endpoint}/{entity}/{id}',
endpoint=self.endpoint, entity=self.entity, id=resource_id,
paginate=False
)
return response.json() | Get a history element
:param resource_id: ... |
def delete_comment(self, resource_id, ent_id):
self.requester.post(
'/{endpoint}/{entity}/{id}/delete_comment?id={ent_id}',
endpoint=self.endpoint, entity=self.entity,
id=resource_id, ent_id=ent_id
) | Delete a comment
:param resource_id: ...
:param ent_id: ... |
def parse(cls, value):
if is_list_annotation(cls):
if not isinstance(value, list):
raise TypeError('Could not parse {} because value is not a list'.format(cls))
return [parse(cls.__args__[0], o) for o in value]
else:
return GenericParser(cls, ModelProviderImpl()).parse(v... | Takes a class and a dict and try to build an instance of the class
:param cls: The class to parse
:param value: either a dict, a list or a scalar value |
def dump(obj, fp, **kwargs):
kwargs['default'] = serialize
return json.dump(obj, fp, **kwargs) | wrapper for :py:func:`json.dump` |
def load(cls, fp, **kwargs):
json_obj = json.load(fp, **kwargs)
return parse(cls, json_obj) | wrapper for :py:func:`json.load` |
def loads(cls, s, **kwargs):
json_obj = json.loads(s, **kwargs)
return parse(cls, json_obj) | wrapper for :py:func:`json.loads` |
def convert_ensembl_to_entrez(self, ensembl):
if 'ENST' in ensembl:
pass
else:
raise (IndexError)
# Submit resquest to NCBI eutils/Gene database
server = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?" + self.options + "&db=gene&term={0}".for... | Convert Ensembl Id to Entrez Gene Id |
def convert_entrez_to_uniprot(self, entrez):
server = "http://www.uniprot.org/uniprot/?query=%22GENEID+{0}%22&format=xml".format(entrez)
r = requests.get(server, headers={"Content-Type": "text/xml"})
if not r.ok:
r.raise_for_status()
sys.exit()
response =... | Convert Entrez Id to Uniprot Id |
def convert_uniprot_to_entrez(self, uniprot):
# Submit request to NCBI eutils/Gene Database
server = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?" + self.options + "&db=gene&term={0}".format(
uniprot)
r = requests.get(server, headers={"Content-Type": "text/xml... | Convert Uniprot Id to Entrez Id |
def convert_accession_to_taxid(self, accessionid):
# Submit request to NCBI eutils/Taxonomy Database
server = "http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?" + self.options + "&db=nuccore&id={0}&retmode=xml".format(
accessionid)
r = requests.get(server, headers={... | Convert Accession Id to Tax Id |
def convert_symbol_to_entrezid(self, symbol):
entrezdict = {}
server = "http://rest.genenames.org/fetch/symbol/{0}".format(symbol)
r = requests.get(server, headers={"Content-Type": "application/json"})
if not r.ok:
r.raise_for_status()
sys.exit()
... | Convert Symbol to Entrez Gene Id |
def log_local_message(message_format, *args):
prefix = '{} {}'.format(color('INFO', fg=248), color('request', fg=5))
message = message_format % args
sys.stderr.write('{} {}\n'.format(prefix, message)) | Log a request so that it matches our local log format. |
def serialize(obj):
if isinstance(obj, list):
return [serialize(o) for o in obj]
return GenericSerializer(ModelProviderImpl()).serialize(obj) | Takes a object and produces a dict-like representation
:param obj: the object to serialize |
def of(self, *indented_blocks) -> "CodeBlock":
if self.closed_by is None:
self.expects_body_or_pass = True
for block in indented_blocks:
if block is not None:
self._blocks.append((1, block))
# Finalise it so that we cannot add more sub-blocks t... | By default, marks the block as expecting an indented "body" blocks of which are then supplied
as arguments to this method.
Unless the block specifies a "closed_by", if no body blocks are supplied or they are all Nones,
this will generate a "pass" statement as the body. If there is a "closed_by"... |
def add(self, *blocks, indentation=0) -> "CodeBlock":
for block in blocks:
if block is not None:
self._blocks.append((indentation, block))
return self | Adds sub-blocks at the specified indentation level, which defaults to 0.
Nones are skipped.
Returns the parent block itself, useful for chaining. |
def get_blocks(self):
self.process_triple_quoted_doc_string()
num_indented_blocks = 0
for indentation, block in self._blocks:
if indentation > 0:
num_indented_blocks += 1
yield indentation, block
if self.expects_body_or_pass and num_ind... | Override this method for custom content, but then you are responsible for:
- generating doc string (you can call self.process_triple_quoted_doc_string())
- generating "pass" on empty body |
def to_code(self, context: Context =None):
# Do not override this method!
context = context or Context()
for imp in self.imports:
if imp not in context.imports:
context.imports.append(imp)
counter = Counter()
lines = list(self.to_lines(conte... | Generate the code and return it as a string. |
def exec(self, globals=None, locals=None):
if locals is None:
locals = {}
builtins.exec(self.to_code(), globals, locals)
return locals | Execute simple code blocks.
Do not attempt this on modules or other blocks where you have
imports as they won't work.
Instead write the code to a file and use runpy.run_path() |
def block(self, *blocks, **kwargs) -> "CodeBlock":
assert "name" not in kwargs
kwargs.setdefault("code", self)
code = CodeBlock(**kwargs)
for block in blocks:
if block is not None:
code._blocks.append((0, block))
return code | Build a basic code block.
Positional arguments should be instances of CodeBlock or strings.
All code blocks passed as positional arguments are added at indentation level 0.
None blocks are skipped. |
def dict_from_locals(self, name, params: List[Parameter], not_specified_literal=Constants.VALUE_NOT_SET):
code = self.block(f"{name} = {{}}")
for p in params:
code.add(
self.block(f"if {p.name} is not {not_specified_literal}:").of(
f"{name}[{p.nam... | Generate code for a dictionary of locals whose value is not the specified literal. |
def import_generated_autoboto(self):
if str(self.config.build_dir) not in sys.path:
sys.path.append(str(self.config.build_dir))
return importlib.import_module(self.config.target_package) | Imports the autoboto package generated in the build directory (not target_dir).
For example:
autoboto = botogen.import_generated_autoboto() |
def import_generated_autoboto_module(self, name):
if str(self.config.build_dir) not in sys.path:
sys.path.append(str(self.config.build_dir))
return importlib.import_module(f"{self.config.target_package}.{name}") | Imports a module from the generated autoboto package in the build directory (not target_dir).
For example, to import autoboto.services.s3.shapes, call:
botogen.import_generated_autoboto_module("services.s3.shapes") |
def search(self, project, text=''):
result = self.raw_request.get(
'search', query={'project': project, 'text': text}
)
result = result.json()
search_result = SearchResult()
search_result.tasks = self.tasks.parse_list(result['tasks'])
search_result.is... | Search in your Taiga.io instance
:param project: the project id
:param text: the query of your search |
def auth(self, username, password):
headers = {
'Content-type': 'application/json'
}
payload = {
'type': self.auth_type,
'username': username,
'password': password
}
try:
full_url = utils.urljoin(self.host, '/ap... | Authenticate you
:param username: your username
:param password: your password |
def auth_app(self, app_id, app_secret, auth_code, state=''):
headers = {
'Content-type': 'application/json'
}
payload = {
'application': app_id,
'auth_code': auth_code,
'state': state
}
try:
full_url = utils.url... | Authenticate an app
:param app_id: the app id
:param app_secret: the app secret
:param auth_code: the app auth code |
def sorted_members(self):
members = collections.OrderedDict()
required_names = self.metadata.get("required", ())
for name, shape in self.members.items():
members[name] = AbShapeMember(name=name, shape=shape, is_required=name in required_names)
if self.is_output_shap... | Iterate over sorted members of shape in the same order in which
the members are declared except yielding the required members before
any optional members. |
def update(self):
self.frontends = []
self.backends = []
self.listeners = []
csv = [ l for l in self._fetch().strip(' #').split('\n') if l ]
if self.failed:
return
#read fields header to create keys
self.fields = [ f for f in csv.pop(0).spli... | Fetch and parse stats |
def _decode(value):
if value.isdigit():
return int(value)
if isinstance(value, bytes):
return value.decode('utf-8')
else:
return value | decode byte strings and convert to int where needed |
def markdown(text, renderer=None, **options):
ext, rndr = make_flags(**options)
if renderer:
md = misaka.Markdown(renderer,ext)
result = md(text)
else:
result = misaka.html(text, extensions=ext, render_flags=rndr)
if options.get("smartypants"):
result = misaka.smarty... | Parses the provided Markdown-formatted text into valid HTML, and returns
it as a :class:`flask.Markup` instance.
:param text: Markdown-formatted text to be rendered into HTML
:param renderer: A custom misaka renderer to be used instead of the default one
:param options: Additional options for customizi... |
def render(self, text, **overrides):
options = self.defaults
if overrides:
options = copy(options)
options.update(overrides)
return markdown(text, self.renderer, **options) | It delegates to the :func:`markdown` function, passing any default
options or renderer set in the :meth:`__init__` method.
The ``markdown`` template filter calls this method.
:param text: Markdown-formatted text to be rendered to HTML
:param overrides: Additional options which may over... |
def caseinsensitive(cls):
if not issubclass(cls, Enum):
raise TypeError('caseinsensitive decorator can only be applied to subclasses of enum.Enum')
enum_options = getattr(cls, PYCKSON_ENUM_OPTIONS, {})
enum_options[ENUM_CASE_INSENSITIVE] = True
setattr(cls, PYCKSON_ENUM_OPTIONS, enum_option... | Annotation function to set an Enum to be case insensitive on parsing |
def win32_utf8_argv():
try:
from ctypes import POINTER, byref, cdll, c_int, windll
from ctypes.wintypes import LPCWSTR, LPWSTR
GetCommandLineW = cdll.kernel32.GetCommandLineW
GetCommandLineW.argtypes = []
GetCommandLineW.restype = LPCWSTR
CommandLineToArgvW = ... | Uses shell32.GetCommandLineArgvW to get sys.argv as a list of UTF-8
strings.
Versions 2.5 and older of Python don't support Unicode in sys.argv on
Windows, with the underlying Windows API instead replacing multi-byte
characters with '?'.
Returns None on failure.
Example usage:
>>> def ma... |
def encrypt_ascii(self, data, key=None, v=None, extra_bytes=0,
digest="hex"):
digests = {"hex": binascii.b2a_hex,
"base64": binascii.b2a_base64,
"hqx": binascii.b2a_hqx}
digestor = digests.get(digest)
if not digestor:
... | Encrypt data and return as ascii string. Hexadecimal digest as default.
Avaiable digests:
hex: Hexadecimal
base64: Base 64
hqx: hexbin4 |
def decrypt_ascii(self, ascii_string, key=None, digest="hex"):
digests = {"hex": binascii.a2b_hex,
"base64": binascii.a2b_base64,
"hqx": binascii.a2b_hqx}
digestor = digests.get(digest)
if not digestor:
TripleSecError(u"Digestor not supp... | Receive ascii string and return decrypted data.
Avaiable digests:
hex: Hexadecimal
base64: Base 64
hqx: hexbin4 |
def resolve_movie(self, title, year=None):
r = self.search_movie(title)
return self._match_results(r, title, year) | Tries to find a movie with a given title and year |
def resolve_tv_show(self, title, year=None):
r = self.search_tv_show(title)
return self._match_results(r, title, year) | Tries to find a movie with a given title and year |
def load_heroes():
filename = os.path.join(os.path.dirname(__file__), "data", "heroes.json")
with open(filename) as f:
heroes = json.loads(f.read())["result"]["heroes"]
for hero in heroes:
HEROES_CACHE[hero["id"]] = hero | Load hero details from JSON file into memoy |
def load_items():
filename = os.path.join(os.path.dirname(__file__), "data", "items.json")
with open(filename) as f:
items = json.loads(f.read())["result"]["items"]
for item in items:
ITEMS_CACHE[item["id"]] = item | Load item details fom JSON file into memory |
def added(self, context):
context.cmd_tree = self._build_cmd_tree(self.command)
context.cmd_toplevel = context.cmd_tree.cmd_obj
# Collect spices from the top-level command
for spice in context.cmd_toplevel.get_cmd_spices():
context.bowl.add_spice(spice) | Ingredient method called before anything else.
Here this method just builds the full command tree and stores it inside
the context as the ``cmd_tree`` attribute. The structure of the tree is
explained by the :func:`build_cmd_tree()` function. |
def _build_cmd_tree(self, cmd_cls, cmd_name=None):
if isinstance(cmd_cls, type):
cmd_obj = cmd_cls()
else:
cmd_obj = cmd_cls
if cmd_name is None:
cmd_name = cmd_obj.get_cmd_name()
return cmd_tree_node(cmd_name, cmd_obj, tuple([
sel... | Build a tree of commands.
:param cmd_cls:
The Command class or object to start with.
:param cmd_name:
Hard-coded name of the command (can be None for auto-detection)
:returns:
A tree structure represented as tuple
``(cmd_obj, cmd_name, childre... |
def debug_dump(message, file_prefix="dump"):
global index
index += 1
with open("%s_%s.dump" % (file_prefix, index), 'w') as f:
f.write(message.SerializeToString())
f.close() | Utility while developing to dump message data to play with in the
interpreter |
def get_side_attr(attr, invert, player):
t = player.team
if invert:
t = not player.team
return getattr(player, "%s_%s" % ("goodguy" if t else "badguy", attr)) | Get a player attribute that depends on which side the player is on.
A creep kill for a radiant hero is a badguy_kill, while a creep kill
for a dire hero is a goodguy_kill. |
def creep_kill(self, target, timestamp):
self.creep_kill_types[target] += 1
matched = False
for k, v in self.creep_types.iteritems():
if target.startswith(k):
matched = True
setattr(self, v, getattr(self, v) + 1)
break
... | A creep was tragically killed. Need to split this into radiant/dire
and neutrals |
def calculate_kills(self):
aegises = deque(self.aegis)
next_aegis = aegises.popleft() if aegises else None
aegis_expires = None
active_aegis = None
real_kills = []
for kill in self.kills:
if next_aegis and next_aegis[0] < kill["tick"]:
... | At the end of the game calculate kills/deaths, taking aegis into account
This has to be done at the end when we have a playerid : hero map |
def parse_say_text(self, event):
if event.chat and event.format == "DOTA_Chat_All":
self.chatlog.append((event.prefix, event.text)) | All chat |
def parse_dota_um(self, event):
if event.type == dota_usermessages_pb2.CHAT_MESSAGE_AEGIS:
self.aegis.append((self.tick, event.playerid_1)) | The chat messages that arrive when certain events occur.
The most useful ones are CHAT_MESSAGE_RUNE_PICKUP,
CHAT_MESSAGE_RUNE_BOTTLE, CHAT_MESSAGE_GLYPH_USED,
CHAT_MESSAGE_TOWER_KILL |
def parse_player_info(self, player):
if not player.ishltv:
self.player_info[player.name] = {
"user_id": player.userID,
"guid": player.guid,
"bot": player.fakeplayer,
} | Parse a PlayerInfo struct. This arrives before a FileInfo message |
def parse_file_info(self, file_info):
self.info["playback_time"] = file_info.playback_time
self.info["match_id"] = file_info.game_info.dota.match_id
self.info["game_mode"] = file_info.game_info.dota.game_mode
self.info["game_winner"] = file_info.game_info.dota.game_winner
... | The CDemoFileInfo contains our winners as well as the length of the
demo |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.