Search is not available for this dataset
text stringlengths 75 104k |
|---|
def create_model(self, model):
"""Ran when a new model is created."""
super().create_model(model)
for mixin in self.post_processing_mixins:
mixin.create_model(model) |
def delete_model(self, model):
"""Ran when a model is being deleted."""
for mixin in self.post_processing_mixins:
mixin.delete_model(model)
super().delete_model(model) |
def alter_db_table(self, model, old_db_table, new_db_table):
"""Ran when the name of a model is changed."""
super(SchemaEditor, self).alter_db_table(
model, old_db_table, new_db_table
)
for mixin in self.post_processing_mixins:
mixin.alter_db_table(
... |
def add_field(self, model, field):
"""Ran when a field is added to a model."""
super(SchemaEditor, self).add_field(model, field)
for mixin in self.post_processing_mixins:
mixin.add_field(model, field) |
def remove_field(self, model, field):
"""Ran when a field is removed from a model."""
for mixin in self.post_processing_mixins:
mixin.remove_field(model, field)
super(SchemaEditor, self).remove_field(model, field) |
def alter_field(self, model, old_field, new_field, strict=False):
"""Ran when the configuration on a field changed."""
super(SchemaEditor, self).alter_field(
model, old_field, new_field, strict
)
for mixin in self.post_processing_mixins:
mixin.alter_field(
... |
def prepare_database(self):
"""Ran to prepare the configured database.
This is where we enable the `hstore` extension
if it wasn't enabled yet."""
super().prepare_database()
with self.cursor() as cursor:
try:
cursor.execute('CREATE EXTENSION IF NOT E... |
def get_prep_value(self, value):
"""Override the base class so it doesn't cast all values
to strings.
psqlextra supports expressions in hstore fields, so casting
all values to strings is a bad idea."""
value = Field.get_prep_value(self, value)
if isinstance(value, dict... |
def deconstruct(self):
"""Gets the values to pass to :see:__init__ when
re-creating this object."""
name, path, args, kwargs = super(
HStoreField, self).deconstruct()
if self.uniqueness is not None:
kwargs['uniqueness'] = self.uniqueness
if self.require... |
def _prepare_query_values(self):
"""Extra prep on query values by converting
dictionaries into :see:HStoreValue expressions.
This allows putting expressions in a dictionary.
The :see:HStoreValue will take care of resolving
the expressions inside the dictionary."""
new_q... |
def _form_returning(self):
"""Builds the RETURNING part of the query."""
qn = self.connection.ops.quote_name
return ' RETURNING %s' % qn(self.query.model._meta.pk.attname) |
def as_sql(self, return_id=False):
"""Builds the SQL INSERT statement."""
queries = [
self._rewrite_insert(sql, params, return_id)
for sql, params in super().as_sql()
]
return queries |
def _rewrite_insert(self, sql, params, return_id=False):
"""Rewrites a formed SQL INSERT query to include
the ON CONFLICT clause.
Arguments:
sql:
The SQL INSERT query to rewrite.
params:
The parameters passed to the query.
re... |
def _rewrite_insert_update(self, sql, params, returning):
"""Rewrites a formed SQL INSERT query to include
the ON CONFLICT DO UPDATE clause."""
update_columns = ', '.join([
'{0} = EXCLUDED.{0}'.format(self.qn(field.column))
for field in self.query.update_fields
]... |
def _rewrite_insert_nothing(self, sql, params, returning):
"""Rewrites a formed SQL INSERT query to include
the ON CONFLICT DO NOTHING clause."""
# build the conflict target, the columns to watch
# for conflicts
conflict_target = self._build_conflict_target()
where_clau... |
def _build_conflict_target(self):
"""Builds the `conflict_target` for the ON CONFLICT
clause."""
conflict_target = []
if not isinstance(self.query.conflict_target, list):
raise SuspiciousOperation((
'%s is not a valid conflict target, specify '
... |
def _get_model_field(self, name: str):
"""Gets the field on a model with the specified name.
Arguments:
name:
The name of the field to look for.
This can be both the actual field name, or
the name of the column, both will work :)
Ret... |
def _format_field_name(self, field_name) -> str:
"""Formats a field's name for usage in SQL.
Arguments:
field_name:
The field name to format.
Returns:
The specified field name formatted for
usage in SQL.
"""
field = self._get... |
def _format_field_value(self, field_name) -> str:
"""Formats a field's value for usage in SQL.
Arguments:
field_name:
The name of the field to format
the value of.
Returns:
The field's value formatted for usage
in SQL.
... |
def _normalize_field_name(self, field_name) -> str:
"""Normalizes a field name into a string by
extracting the field name if it was specified
as a reference to a HStore key (as a tuple).
Arguments:
field_name:
The field name to normalize.
Returns:
... |
def alter_db_table(self, model, old_db_table, new_db_table):
"""Ran when the name of a model is changed."""
for field in model._meta.local_fields:
if not isinstance(field, HStoreField):
continue
for keys in self._iterate_uniqueness_keys(field):
s... |
def add_field(self, model, field):
"""Ran when a field is added to a model."""
for keys in self._iterate_uniqueness_keys(field):
self._create_hstore_unique(
model,
field,
keys
) |
def remove_field(self, model, field):
"""Ran when a field is removed from a model."""
for keys in self._iterate_uniqueness_keys(field):
self._drop_hstore_unique(
model,
field,
keys
) |
def alter_field(self, model, old_field, new_field, strict=False):
"""Ran when the configuration on a field changed."""
is_old_field_hstore = isinstance(old_field, HStoreField)
is_new_field_hstore = isinstance(new_field, HStoreField)
if not is_old_field_hstore and not is_new_field_hstor... |
def _create_hstore_unique(self, model, field, keys):
"""Creates a UNIQUE constraint for the specified hstore keys."""
name = self._unique_constraint_name(
model._meta.db_table, field, keys)
columns = [
'(%s->\'%s\')' % (field.column, key)
for key in keys
... |
def _rename_hstore_unique(self, old_table_name, new_table_name,
old_field, new_field, keys):
"""Renames an existing UNIQUE constraint for the specified
hstore keys."""
old_name = self._unique_constraint_name(
old_table_name, old_field, keys)
new... |
def _drop_hstore_unique(self, model, field, keys):
"""Drops a UNIQUE constraint for the specified hstore keys."""
name = self._unique_constraint_name(
model._meta.db_table, field, keys)
sql = self.sql_hstore_unique_drop.format(name=self.quote_name(name))
self.execute(sql) |
def _unique_constraint_name(table: str, field, keys):
"""Gets the name for a UNIQUE INDEX that applies
to one or more keys in a hstore field.
Arguments:
table:
The name of the table the field is
a part of.
field:
The hstor... |
def _iterate_uniqueness_keys(self, field):
"""Iterates over the keys marked as "unique"
in the specified field.
Arguments:
field:
The field of which key's to
iterate over.
"""
uniqueness = getattr(field, 'uniqueness', None)
if... |
def add_condition(self, field, value: Any) -> None:
"""Adds an extra condition to this join.
Arguments:
field:
The field that the condition will apply to.
value:
The value to compare.
"""
self.extra_conditions.append((field, valu... |
def as_sql(self, compiler, connection) -> Tuple[str, List[Any]]:
"""Compiles this JOIN into a SQL string."""
sql, params = super().as_sql(compiler, connection)
qn = compiler.quote_name_unless_alias
# generate the extra conditions
extra_conditions = ' AND '.join([
'{... |
def from_join(cls, join: Join) -> 'ConditionalJoin':
"""Creates a new :see:ConditionalJoin from the
specified :see:Join object.
Arguments:
join:
The :see:Join object to create the
:see:ConditionalJoin object from.
Returns:
A :see:... |
def tdist95conf_level(df):
"""Approximate the 95% confidence interval for Student's T distribution.
Given the degrees of freedom, returns an approximation to the 95%
confidence interval for the Student's T distribution.
Args:
df: An integer, the number of degrees of freedom.
Returns:
... |
def pooled_sample_variance(sample1, sample2):
"""Find the pooled sample variance for two samples.
Args:
sample1: one sample.
sample2: the other sample.
Returns:
Pooled sample variance, as a float.
"""
deg_freedom = len(sample1) + len(sample2) - 2
mean1 = statistics.mean... |
def tscore(sample1, sample2):
"""Calculate a t-test score for the difference between two samples.
Args:
sample1: one sample.
sample2: the other sample.
Returns:
The t-test score, as a float.
"""
if len(sample1) != len(sample2):
raise ValueError("different number of ... |
def is_significant(sample1, sample2):
"""Determine whether two samples differ significantly.
This uses a Student's two-sample, two-tailed t-test with alpha=0.95.
Args:
sample1: one sample.
sample2: the other sample.
Returns:
(significant, t_score) where significant is a bool i... |
def topoSort(roots, getParents):
"""Return a topological sorting of nodes in a graph.
roots - list of root nodes to search from
getParents - function which returns the parents of a given node
"""
results = []
visited = set()
# Use iterative version to avoid stack limits for large datasets... |
def permutations(iterable, r=None):
"""permutations(range(3), 2) --> (0,1) (0,2) (1,0) (1,2) (2,0) (2,1)"""
pool = tuple(iterable)
n = len(pool)
if r is None:
r = n
indices = list(range(n))
cycles = list(range(n - r + 1, n + 1))[::-1]
yield tuple(pool[i] for i in indices[:r])
whi... |
def n_queens(queen_count):
"""N-Queens solver.
Args:
queen_count: the number of queens to solve for. This is also the
board size.
Yields:
Solutions to the problem. Each yielded value is looks like
(3, 8, 2, 1, 4, ..., 6) where each number is the column position for the
... |
def play(self, board):
""" uct tree search """
color = board.color
node = self
path = [node]
while True:
pos = node.select(board)
if pos == PASS:
break
board.move(pos)
child = node.pos_child[pos]
if not c... |
def select(self, board):
""" select move; unexplored children first, then according to uct value """
if self.unexplored:
i = random.randrange(len(self.unexplored))
pos = self.unexplored[i]
self.unexplored[i] = self.unexplored[len(self.unexplored) - 1]
self... |
def random_playout(self, board):
""" random play until both players pass """
for x in range(MAXMOVES): # XXX while not self.finished?
if board.finished:
break
board.move(board.random_move()) |
def update_path(self, board, color, path):
""" update win/loss count along path """
wins = board.score(BLACK) >= board.score(WHITE)
for node in path:
if color == BLACK:
color = WHITE
else:
color = BLACK
if wins == (color == BLAC... |
def filter_benchmarks(benchmarks, bench_funcs, base_ver):
"""Filters out benchmarks not supported by both Pythons.
Args:
benchmarks: a set() of benchmark names
bench_funcs: dict mapping benchmark names to functions
python: the interpereter commands (as lists)
Returns:
The f... |
def expand_benchmark_name(bm_name, bench_groups):
"""Recursively expand name benchmark names.
Args:
bm_name: string naming a benchmark or benchmark group.
Yields:
Names of actual benchmarks, with all group names fully expanded.
"""
expansion = bench_groups.get(bm_name)
if expan... |
def gen_string_table(n):
"""Generates the list of strings that will be used in the benchmarks.
All strings have repeated prefixes and suffices, and n specifies the
number of repetitions.
"""
strings = []
def append(s):
if USE_BYTES_IN_PY3K:
strings.append(s.encode('latin1')... |
def init_benchmarks(n_values=None):
"""Initialize the strings we'll run the regexes against.
The strings used in the benchmark are prefixed and suffixed by
strings that are repeated n times.
The sequence n_values contains the values for n.
If n_values is None the values of n from the original benc... |
def combinations(l):
"""Pure-Python implementation of itertools.combinations(l, 2)."""
result = []
for x in xrange(len(l) - 1):
ls = l[x + 1:]
for y in ls:
result.append((l[x], y))
return result |
def GetDomain(self):
"""Returns the domain of the B-Spline"""
return (self.knots[self.degree - 1],
self.knots[len(self.knots) - self.degree]) |
def fetch_items(self, category, **kwargs):
"""Fetch the messages.
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
from_date = kwargs['from_date']
logger.info("Fetching messages of '%s' - '%s' c... |
def _init_client(self, from_archive=False):
"""Init client"""
return MattermostClient(self.url, self.api_token,
max_items=self.max_items,
sleep_for_rate=self.sleep_for_rate,
min_rate_to_sleep=self.min_rate_t... |
def _parse_posts(self, raw_posts):
"""Parse posts and returns in order."""
parsed_posts = self.parse_json(raw_posts)
# Posts are not sorted. The order is provided by
# 'order' key.
for post_id in parsed_posts['order']:
yield parsed_posts['posts'][post_id] |
def posts(self, channel, page=None):
"""Fetch the history of a channel."""
entrypoint = self.RCHANNELS + '/' + channel + '/' + self.RPOSTS
params = {
self.PPER_PAGE: self.max_items
}
if page is not None:
params[self.PPAGE] = page
response = sel... |
def user(self, user):
"""Fetch user data."""
entrypoint = self.RUSERS + '/' + user
response = self._fetch(entrypoint, None)
return response |
def _fetch(self, entry_point, params):
"""Fetch a resource.
:param entrypoint: entrypoint to access
:param params: dict with the HTTP parameters needed to access the
given entry point
"""
url = self.API_URL % {'base_url': self.base_url, 'entrypoint': entry_point}
... |
def _pre_init(self):
"""Initialize mailing lists directory path"""
if not self.parsed_args.mboxes_path:
base_path = os.path.expanduser('~/.perceval/mailinglists/')
dirpath = os.path.join(base_path, self.parsed_args.url)
else:
dirpath = self.parsed_args.mboxes... |
def fetch(self, from_date=DEFAULT_DATETIME):
"""Fetch the mbox files from the remote archiver.
Stores the archives in the path given during the initialization
of this object. Those archives which a not valid extension will
be ignored.
Pipermail archives usually have on their fi... |
def mboxes(self):
"""Get the mboxes managed by this mailing list.
Returns the archives sorted by date in ascending order.
:returns: a list of `.MBoxArchive` objects
"""
archives = []
for mbox in super().mboxes:
dt = self._parse_date_from_filepath(mbox.filep... |
def fetch(self, category=CATEGORY_ENTRY):
"""Fetch the entries from the url.
The method retrieves all entries from a RSS url
:param category: the category of items to fetch
:returns: a generator of entries
"""
kwargs = {}
items = super().fetch(category, **kwarg... |
def fetch_items(self, category, **kwargs):
"""Fetch the entries
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
logger.info("Looking for rss entries at feed '%s'", self.url)
nentries = 0 # num... |
def _init_client(self, from_archive=False):
"""Init client"""
return RSSClient(self.url, self.archive, from_archive) |
def setup_cmd_parser(cls):
"""Returns the RSS argument parser."""
parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,
archive=True)
# Required arguments
parser.parser.add_argument('url',
help="UR... |
def fetch(self, category=CATEGORY_BUG, from_date=DEFAULT_DATETIME):
"""Fetch the bugs from the repository.
The method retrieves, from a Bugzilla repository, the bugs
updated since the given date.
:param category: the category of items to fetch
:param from_date: obtain bugs upda... |
def fetch_items(self, category, **kwargs):
"""Fetch the bugs
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
from_date = kwargs['from_date']
logger.info("Looking for bugs: '%s' updated from '%... |
def _init_client(self, from_archive=False):
"""Init client"""
return BugzillaRESTClient(self.url, user=self.user, password=self.password, api_token=self.api_token,
archive=self.archive, from_archive=from_archive) |
def login(self, user, password):
"""Authenticate a user in the server.
:param user: Bugzilla user
:param password: user password
"""
params = {
self.PBUGZILLA_LOGIN: user,
self.PBUGZILLA_PASSWORD: password
}
try:
r = self.call... |
def bugs(self, from_date=DEFAULT_DATETIME, offset=None, max_bugs=MAX_BUGS):
"""Get the information of a list of bugs.
:param from_date: retrieve bugs that where updated from that date;
dates are converted to UTC
:param offset: starting position for the search; i.e to return 11th
... |
def comments(self, *bug_ids):
"""Get the comments of the given bugs.
:param bug_ids: list of bug identifiers
"""
# Hack. The first value must be a valid bug id
resource = urijoin(self.RBUG, bug_ids[0], self.RCOMMENT)
params = {
self.PIDS: bug_ids
}
... |
def history(self, *bug_ids):
"""Get the history of the given bugs.
:param bug_ids: list of bug identifiers
"""
resource = urijoin(self.RBUG, bug_ids[0], self.RHISTORY)
params = {
self.PIDS: bug_ids
}
response = self.call(resource, params)
r... |
def attachments(self, *bug_ids):
"""Get the attachments of the given bugs.
:param bug_id: list of bug identifiers
"""
resource = urijoin(self.RBUG, bug_ids[0], self.RATTACHMENT)
params = {
self.PIDS: bug_ids,
self.PEXCLUDE_FIELDS: self.VEXCLUDE_ATTCH_DAT... |
def call(self, resource, params):
"""Retrive the given resource.
:param resource: resource to retrieve
:param params: dict with the HTTP parameters needed to retrieve
the given resource
:raises BugzillaRESTError: raised when an error is returned by
the server
... |
def sanitize_for_archive(url, headers, payload):
"""Sanitize payload of a HTTP request by removing the login, password and token information
before storing/retrieving archived items
:param: url: HTTP url request
:param: headers: HTTP headers request
:param: payload: HTTP payload... |
def fetch_items(self, category, **kwargs):
"""Fetch the items (issues or merge_requests)
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
from_date = kwargs['from_date']
if category == CATEGORY_... |
def __fetch_issues(self, from_date):
"""Fetch the issues"""
issues_groups = self.client.issues(from_date=from_date)
for raw_issues in issues_groups:
issues = json.loads(raw_issues)
for issue in issues:
issue_id = issue['iid']
if self.bla... |
def __get_issue_notes(self, issue_id):
"""Get issue notes"""
notes = []
group_notes = self.client.notes(GitLabClient.ISSUES, issue_id)
for raw_notes in group_notes:
for note in json.loads(raw_notes):
note_id = note['id']
note['award_emoji_d... |
def __fetch_merge_requests(self, from_date):
"""Fetch the merge requests"""
merges_groups = self.client.merges(from_date=from_date)
for raw_merges in merges_groups:
merges = json.loads(raw_merges)
for merge in merges:
merge_id = merge['iid']
... |
def __get_merge_notes(self, merge_id):
"""Get merge notes"""
notes = []
group_notes = self.client.notes(GitLabClient.MERGES, merge_id)
for raw_notes in group_notes:
for note in json.loads(raw_notes):
note_id = note['id']
note['award_emoji_da... |
def __get_merge_versions(self, merge_id):
"""Get merge versions"""
versions = []
group_versions = self.client.merge_versions(merge_id)
for raw_versions in group_versions:
for version in json.loads(raw_versions):
version_id = version['id']
ve... |
def __get_award_emoji(self, item_type, item_id):
"""Get award emojis for issue/merge request"""
emojis = []
group_emojis = self.client.emojis(item_type, item_id)
for raw_emojis in group_emojis:
for emoji in json.loads(raw_emojis):
emojis.append(emoji)
... |
def __get_note_award_emoji(self, item_type, item_id, note_id):
"""Fetch emojis for a note of an issue/merge request"""
emojis = []
group_emojis = self.client.note_emojis(item_type, item_id, note_id)
try:
for raw_emojis in group_emojis:
for emoji in json.loa... |
def issues(self, from_date=None):
"""Get the issues from pagination"""
payload = {
'state': 'all',
'order_by': 'updated_at',
'sort': 'asc',
'per_page': PER_PAGE
}
if from_date:
payload['updated_after'] = from_date.isoformat()
... |
def merges(self, from_date=None):
"""Get the merge requests from pagination"""
payload = {
'state': 'all',
'order_by': 'updated_at',
'sort': 'asc',
'view': 'simple',
'per_page': PER_PAGE
}
if from_date:
payload['up... |
def merge(self, merge_id):
"""Get the merge full data"""
path = urijoin(self.base_url,
GitLabClient.PROJECTS, self.owner + '%2F' + self.repository,
GitLabClient.MERGES, merge_id)
response = self.fetch(path)
return response.text |
def merge_versions(self, merge_id):
"""Get the merge versions from pagination"""
payload = {
'order_by': 'updated_at',
'sort': 'asc',
'per_page': PER_PAGE
}
path = urijoin(GitLabClient.MERGES, str(merge_id), GitLabClient.VERSIONS)
return self... |
def merge_version(self, merge_id, version_id):
"""Get merge version detail"""
path = urijoin(self.base_url,
GitLabClient.PROJECTS, self.owner + '%2F' + self.repository,
GitLabClient.MERGES, merge_id, GitLabClient.VERSIONS, version_id)
response = se... |
def notes(self, item_type, item_id):
"""Get the notes from pagination"""
payload = {
'order_by': 'updated_at',
'sort': 'asc',
'per_page': PER_PAGE
}
path = urijoin(item_type, str(item_id), GitLabClient.NOTES)
return self.fetch_items(path, pa... |
def emojis(self, item_type, item_id):
"""Get emojis from pagination"""
payload = {
'order_by': 'updated_at',
'sort': 'asc',
'per_page': PER_PAGE
}
path = urijoin(item_type, str(item_id), GitLabClient.EMOJI)
return self.fetch_items(path, payl... |
def note_emojis(self, item_type, item_id, note_id):
"""Get emojis of a note"""
payload = {
'order_by': 'updated_at',
'sort': 'asc',
'per_page': PER_PAGE
}
path = urijoin(item_type, str(item_id), GitLabClient.NOTES,
str(note_id)... |
def calculate_time_to_reset(self):
"""Calculate the seconds to reset the token requests, by obtaining the different
between the current date and the next date when the token is fully regenerated.
"""
time_to_reset = self.rate_limit_reset_ts - (datetime_utcnow().replace(microsecond=0).ti... |
def fetch(self, url, payload=None, headers=None, method=HttpClient.GET, stream=False):
"""Fetch the data from a given URL.
:param url: link to the resource
:param payload: payload of the request
:param headers: headers of the request
:param method: type of request call (GET or P... |
def fetch_items(self, path, payload):
"""Return the items from GitLab API using links pagination"""
page = 0 # current page
last_page = None # last page
url_next = urijoin(self.base_url, GitLabClient.PROJECTS, self.owner + '%2F' + self.repository, path)
logger.debug("Get GitL... |
def sanitize_for_archive(url, headers, payload):
"""Sanitize payload of a HTTP request by removing the token information
before storing/retrieving archived items
:param: url: HTTP url request
:param: headers: HTTP headers request
:param: payload: HTTP payload request
:r... |
def _init_rate_limit(self):
"""Initialize rate limit information"""
url = urijoin(self.base_url, 'projects', self.owner + '%2F' + self.repository)
try:
response = super().fetch(url)
self.update_rate_limit(response)
except requests.exceptions.HTTPError as error:
... |
def setup_cmd_parser(cls):
"""Returns the GitLab argument parser."""
parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,
from_date=True,
token_auth=True,
a... |
def fetch(self, category=CATEGORY_MESSAGE, from_date=DEFAULT_DATETIME):
"""Fetch the messages from the channel.
This method fetches the messages stored on the channel that were
sent since the given date.
:param category: the category of items to fetch
:param from_date: obtain m... |
def fetch_items(self, category, **kwargs):
"""Fetch the messages
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
from_date = kwargs['from_date']
latest = kwargs['latest']
logger.info("F... |
def metadata_id(item):
"""Extracts the identifier from a Slack item.
This identifier will be the mix of two fields because Slack
messages does not have any unique identifier. In this case,
'ts' and 'user' values (or 'bot_id' when the message is sent by a bot)
are combined becaus... |
def _init_client(self, from_archive=False):
"""Init client"""
return SlackClient(self.api_token, self.max_items, self.archive, from_archive) |
def conversation_members(self, conversation):
"""Fetch the number of members in a conversation, which is a supertype for public and
private ones, DM and group DM.
:param conversation: the ID of the conversation
"""
members = 0
resource = self.RCONVERSATION_INFO
... |
def channel_info(self, channel):
"""Fetch information about a channel."""
resource = self.RCHANNEL_INFO
params = {
self.PCHANNEL: channel,
}
response = self._fetch(resource, params)
return response |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.