_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q269000 | Git.parse_git_log_from_file | test | def parse_git_log_from_file(filepath):
"""Parse a Git log file.
The method parses the Git log file and returns an iterator of
dictionaries. Each one of this, contains a commit.
:param filepath: path to the log file
:returns: a generator of parsed commits
:raises ParseError: raised when the format of the Git log file
is invalid
:raises OSError: raised when an error occurs reading the
given file
| python | {
"resource": ""
} |
q269001 | GitCommand._pre_init | test | def _pre_init(self):
"""Initialize repositories directory path"""
if self.parsed_args.git_log:
git_path = self.parsed_args.git_log
elif not self.parsed_args.git_path:
base_path = os.path.expanduser('~/.perceval/repositories/')
processed_uri = self.parsed_args.uri.lstrip('/')
git_path | python | {
"resource": ""
} |
q269002 | GitCommand.setup_cmd_parser | test | def setup_cmd_parser(cls):
"""Returns the Git argument parser."""
parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,
from_date=True,
to_date=True)
# Optional arguments
group = parser.parser.add_argument_group('Git arguments')
group.add_argument('--branches', dest='branches',
nargs='+', type=str, default=None,
help="Fetch commits only from these branches")
# Mutual exclusive parameters
exgroup = group.add_mutually_exclusive_group()
exgroup.add_argument('--git-path', dest='git_path',
help="Path where the Git repository will be cloned")
exgroup.add_argument('--git-log', dest='git_log',
help="Path to the Git log file")
exgroup_fetch = group.add_mutually_exclusive_group()
exgroup_fetch.add_argument('--latest-items', dest='latest_items',
| python | {
"resource": ""
} |
q269003 | GitParser.parse | test | def parse(self):
"""Parse the Git log stream."""
for line in self.stream:
line = line.rstrip('\n')
parsed = False
self.nline += 1
while not parsed:
parsed = self.handlers[self.state](line)
if self.state == self.COMMIT and self.commit:
commit = self._build_commit()
logger.debug("Commit %s parsed", commit['commit'])
| python | {
"resource": ""
} |
q269004 | GitRepository.clone | test | def clone(cls, uri, dirpath):
"""Clone a Git repository.
Make a bare copy of the repository stored in `uri` into `dirpath`.
The repository would be either local or remote.
:param uri: URI of the repository
:param dirtpath: directory where the repository will be cloned
:returns: a `GitRepository` class | python | {
"resource": ""
} |
q269005 | GitRepository.count_objects | test | def count_objects(self):
"""Count the objects of a repository.
The method returns the total number of objects (packed and unpacked)
available on the repository.
:raises RepositoryError: when an error occurs counting the objects
of a repository
"""
cmd_count = ['git', 'count-objects', '-v']
outs = self._exec(cmd_count, cwd=self.dirpath, env=self.gitenv)
outs = outs.decode('utf-8', errors='surrogateescape').rstrip()
try:
cobjs = {k: v for k, v in (x.split(': ') for x in outs.split('\n'))}
nobjs = int(cobjs['count']) + int(cobjs['in-pack'])
except KeyError as e:
| python | {
"resource": ""
} |
q269006 | GitRepository.is_detached | test | def is_detached(self):
"""Check if the repo is in a detached state.
The repository is in a detached state when HEAD is not a symbolic
reference.
:returns: whether the repository is detached or not
:raises RepositoryError: when an error occurs checking | python | {
"resource": ""
} |
q269007 | GitRepository.update | test | def update(self):
"""Update repository from its remote.
Calling this method, the repository will be synchronized with
the remote repository using 'fetch' command for 'heads' refs.
Any commit stored in the local copy will be removed; refs
| python | {
"resource": ""
} |
q269008 | GitRepository.sync | test | def sync(self):
"""Keep the repository in sync.
This method will synchronize the repository with its 'origin',
fetching newest objects and updating references. It uses low
level commands which allow to keep track of which things
have changed in the repository.
The method also returns a list of hashes related to the new
commits fetched during the process.
:returns: list of new commits
:raises RepositoryError: when an error occurs synchronizing
the repository
"""
pack_name, refs = self._fetch_pack()
| python | {
"resource": ""
} |
q269009 | GitRepository.rev_list | test | def rev_list(self, branches=None):
"""Read the list commits from the repository
The list of branches is a list of strings, with the names of the
branches to fetch. If the list of branches is empty, no commit
is fetched. If the list of branches is None, all commits
for all branches will be fetched.
The method returns the Git rev-list of the repository using the
following options:
git rev-list --topo-order
:param branches: names of branches to fetch from (default: None)
:raises EmptyRepositoryError: when the repository is empty and
the action cannot be performed
| python | {
"resource": ""
} |
q269010 | GitRepository.log | test | def log(self, from_date=None, to_date=None, branches=None, encoding='utf-8'):
"""Read the commit log from the repository.
The method returns the Git log of the repository using the
following options:
git log --raw --numstat --pretty=fuller --decorate=full
--all --reverse --topo-order --parents -M -C -c
--remotes=origin
When `from_date` is given, it gets the commits equal or older
than that date. This date is given in a datetime object.
The list of branches is a list of strings, with the names of the
branches to fetch. If the list of branches is empty, no commit
is fetched. If the list of branches is None, all commits
for all branches will be fetched.
:param from_date: fetch commits newer than a specific
date (inclusive)
:param branches: names of branches to fetch from (default: None)
:param encoding: encode the log using this format
:returns: a generator where each item is a line from the log
:raises EmptyRepositoryError: when the repository is empty and
the action cannot be performed
:raises RepositoryError: when an error occurs fetching the log
"""
if self.is_empty():
logger.warning("Git %s repository is empty; unable to get the log",
| python | {
"resource": ""
} |
q269011 | GitRepository.show | test | def show(self, commits=None, encoding='utf-8'):
"""Show the data of a set of commits.
The method returns the output of Git show command for a
set of commits using the following options:
git show --raw --numstat --pretty=fuller --decorate=full
--parents -M -C -c [<commit>...<commit>]
When the list of commits is empty, the command will return
data about the last commit, like the default behaviour of
`git show`.
:param commits: list of commits to show data
:param encoding: encode the output using this format
:returns: a generator where each item is a line from the show output
:raises EmptyRepositoryError: when the repository is empty and
the action cannot be performed
:raises RepositoryError: when an error occurs fetching the show output
"""
if self.is_empty():
logger.warning("Git %s repository is empty; unable to run show",
self.uri)
| python | {
"resource": ""
} |
q269012 | GitRepository._fetch_pack | test | def _fetch_pack(self):
"""Fetch changes and store them in a pack."""
def prepare_refs(refs):
return [ref.hash.encode('utf-8') for ref in refs
if not ref.refname.endswith('^{}')]
def determine_wants(refs):
remote_refs = prepare_refs(self._discover_refs(remote=True))
local_refs = prepare_refs(self._discover_refs())
wants = [ref for ref in remote_refs if ref not in local_refs]
return wants
client, repo_path = dulwich.client.get_transport_and_path(self.uri)
repo = dulwich.repo.Repo(self.dirpath)
fd = io.BytesIO()
local_refs = self._discover_refs()
graph_walker = _GraphWalker(local_refs)
result = client.fetch_pack(repo_path,
determine_wants,
graph_walker,
| python | {
"resource": ""
} |
q269013 | GitRepository._read_commits_from_pack | test | def _read_commits_from_pack(self, packet_name):
"""Read the commits of a pack."""
filepath = 'objects/pack/pack-' + packet_name
cmd_verify_pack = ['git', 'verify-pack', '-v', filepath]
outs = self._exec(cmd_verify_pack, cwd=self.dirpath, env=self.gitenv)
outs = outs.decode('utf-8', errors='surrogateescape').rstrip()
lines = [line.split(' ') for line in outs.split('\n')]
| python | {
"resource": ""
} |
q269014 | GitRepository._update_references | test | def _update_references(self, refs):
"""Update references removing old ones."""
new_refs = [ref.refname for ref in refs]
# Delete old references
for old_ref in self._discover_refs():
if not old_ref.refname.startswith('refs/heads/'):
continue
if old_ref.refname in new_refs:
continue
self._update_ref(old_ref, delete=True)
# Update new references
for new_ref in refs:
| python | {
"resource": ""
} |
q269015 | GitRepository._discover_refs | test | def _discover_refs(self, remote=False):
"""Get the current list of local or remote refs."""
if remote:
cmd_refs = ['git', 'ls-remote', '-h', '-t', '--exit-code', 'origin']
sep = '\t'
ignored_error_codes = [2]
else:
# Check first whether the local repo is empty;
# Running 'show-ref' in empty repos gives an error
if self.is_empty():
raise EmptyRepositoryError(repository=self.uri)
cmd_refs = ['git', 'show-ref', '--heads', '--tags']
sep = ' '
ignored_error_codes = [1]
# Error codes returned when no matching refs (i.e, no heads
# or tags) are found in a repository will | python | {
"resource": ""
} |
q269016 | GitRepository._update_ref | test | def _update_ref(self, ref, delete=False):
"""Update a reference."""
cmd = ['git', 'update-ref']
if delete:
cmd.extend(['-d', ref.refname])
action = 'deleted'
else:
cmd.extend([ref.refname, ref.hash])
action = 'updated to %s' % ref.hash | python | {
"resource": ""
} |
q269017 | GitRepository._exec_nb | test | def _exec_nb(self, cmd, cwd=None, env=None, encoding='utf-8'):
"""Run a command with a non blocking call.
Execute `cmd` command with a non blocking call. The command will
be run in the directory set by `cwd`. Enviroment variables can be
set using the `env` dictionary. The output data is returned
as encoded bytes in an iterator. Each item will be a line of the
output.
:returns: an iterator with the output of the command as encoded bytes
:raises RepositoryError: when an error occurs running the command
"""
self.failed_message = None
logger.debug("Running command %s (cwd: %s, env: %s)",
' '.join(cmd), cwd, str(env))
try:
self.proc = subprocess.Popen(cmd,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=cwd,
env=env)
err_thread = threading.Thread(target=self._read_stderr,
kwargs={'encoding': encoding},
| python | {
"resource": ""
} |
q269018 | GitRepository._read_stderr | test | def _read_stderr(self, encoding='utf-8'):
"""Reads self.proc.stderr.
Usually, this should be read in a thread, to prevent blocking
the read from stdout of the stderr buffer is filled, and this
function is not called becuase the program is busy in the
stderr reading loop.
Reads self.proc.stderr (self.proc is the subprocess running
the git command), and reads / writes self.failed_message
(the message sent to stderr when git fails, usually one line).
| python | {
"resource": ""
} |
q269019 | GitRepository._exec | test | def _exec(cmd, cwd=None, env=None, ignored_error_codes=None,
encoding='utf-8'):
"""Run a command.
Execute `cmd` command in the directory set by `cwd`. Environment
variables can be set using the `env` dictionary. The output
data is returned as encoded bytes.
Commands which their returning status codes are non-zero will
be treated as failed. Error codes considered as valid can be
ignored giving them in the `ignored_error_codes` list.
:returns: the output of the command as encoded bytes
:raises RepositoryError: when an error occurs running the command
"""
if ignored_error_codes is None:
ignored_error_codes = []
logger.debug("Running command %s (cwd: %s, env: %s)",
' '.join(cmd), cwd, str(env))
try:
proc = subprocess.Popen(cmd, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, | python | {
"resource": ""
} |
q269020 | Twitter.fetch | test | def fetch(self, category=CATEGORY_TWEET, since_id=None, max_id=None,
geocode=None, lang=None,
include_entities=True, tweets_type=TWEET_TYPE_MIXED):
"""Fetch the tweets from the server.
This method fetches tweets from the TwitterSearch API published in the last seven days.
:param category: the category of items to fetch
:param since_id: if not null, it returns results with an ID greater than the specified ID
:param max_id: when it is set or if not None, it returns results with an ID less than the specified ID
:param geocode: if enabled, returns tweets by users located at latitude,longitude,"mi"|"km"
:param lang: if enabled, restricts tweets to the given language, given by an ISO 639-1 code
:param include_entities: if disabled, it excludes entities node
| python | {
"resource": ""
} |
q269021 | Twitter.fetch_items | test | def fetch_items(self, category, **kwargs):
"""Fetch the tweets
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
since_id = kwargs['since_id']
max_id = kwargs['max_id']
geocode = kwargs['geocode']
lang = kwargs['lang']
entities = kwargs['include_entities']
tweets_type = kwargs['result_type']
logger.info("Fetching tweets %s from %s to %s",
self.query, str(since_id),
str(max_id) if max_id else '--')
tweets_ids = []
min_date = None
max_date = None
group_tweets = self.client.tweets(self.query, since_id=since_id, max_id=max_id, geocode=geocode,
lang=lang, include_entities=entities, result_type=tweets_type)
for tweets in group_tweets:
for i in range(len(tweets)):
tweet = tweets[i]
| python | {
"resource": ""
} |
q269022 | TwitterClient.tweets | test | def tweets(self, query, since_id=None, max_id=None, geocode=None, lang=None,
include_entities=True, result_type=TWEET_TYPE_MIXED):
"""Fetch tweets for a given query between since_id and max_id.
:param query: query to fetch tweets
:param since_id: if not null, it returns results with an ID greater than the specified ID
:param max_id: if not null, it returns results with an ID less than the specified ID
:param geocode: if enabled, returns tweets by users located at latitude,longitude,"mi"|"km"
:param lang: if enabled, restricts tweets to the given language, given by an ISO 639-1 code
:param include_entities: if disabled, it excludes entities node
:param result_type: type of tweets returned. Default is “mixed”, others are "recent" and "popular"
:returns: a generator of tweets
"""
resource = self.base_url
params = {'q': query,
'count': self.max_items}
if since_id:
params['since_id'] = since_id
if max_id:
| python | {
"resource": ""
} |
q269023 | TwitterCommand.setup_cmd_parser | test | def setup_cmd_parser(cls):
"""Returns the Twitter argument parser."""
parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,
token_auth=True,
archive=True)
# Backend token is required
action = parser.parser._option_string_actions['--api-token']
action.required = True
# Meetup options
group = parser.parser.add_argument_group('Twitter arguments')
group.add_argument('--max-items', dest='max_items',
type=int, default=MAX_ITEMS,
help="Maximum number of items requested on the same query")
group.add_argument('--no-entities', dest='include_entities',
action='store_false',
help=" Exclude entities node")
group.add_argument('--geo-code', dest='geocode',
help="Select tweets by users located at latitude,longitude,radius")
group.add_argument('--lang', dest='lang',
help="Select tweets to the given language in ISO 639-1 code")
group.add_argument('--tweets-type', dest='tweets_type', default=TWEET_TYPE_MIXED,
help="Type of tweets returned. Default is 'mixed', others are 'recent' and 'popular'")
| python | {
"resource": ""
} |
q269024 | GoogleHits.fetch | test | def fetch(self, category=CATEGORY_HITS):
"""Fetch data from Google API.
The method retrieves a list of hits for some
given keywords using the | python | {
"resource": ""
} |
q269025 | GoogleHits.fetch_items | test | def fetch_items(self, category, **kwargs):
"""Fetch Google hit items
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
logger.info("Fetching data for '%s'", self.keywords)
| python | {
"resource": ""
} |
q269026 | GoogleHits.__parse_hits | test | def __parse_hits(self, hit_raw):
"""Parse the hits returned by the Google Search API"""
# Create the soup and get the desired div
bs_result = bs4.BeautifulSoup(hit_raw, 'html.parser')
hit_string = bs_result.find("div", id="resultStats").text
# Remove commas or dots
hit_string = hit_string.replace(',', u'')
hit_string = hit_string.replace('.', u'')
fetched_on = datetime_utcnow().timestamp()
id_args = self.keywords[:]
id_args.append(str(fetched_on))
hits_json = {
'fetched_on': fetched_on,
'id': uuid(*id_args),
| python | {
"resource": ""
} |
q269027 | GoogleHitsClient.hits | test | def hits(self, keywords):
"""Fetch information about a list of keywords."""
if len(keywords) == 1:
query_str = keywords[0]
else:
query_str = ' '.join([k for k in keywords])
logger.info("Fetching hits for '%s'", query_str)
| python | {
"resource": ""
} |
q269028 | GitHub.metadata_updated_on | test | def metadata_updated_on(item):
"""Extracts the update time from a GitHub item.
The timestamp used is extracted from 'updated_at' field.
This date is converted to UNIX timestamp format. As GitHub
dates are in UTC the conversion is straightforward.
:param item: item generated by the backend
:returns: a UNIX timestamp | python | {
"resource": ""
} |
q269029 | GitHub.metadata_category | test | def metadata_category(item):
"""Extracts the category from a GitHub item.
This backend generates two types of item which are
'issue' and 'pull_request'.
"""
if "base" in item:
category = | python | {
"resource": ""
} |
q269030 | GitHub.__fetch_pull_requests | test | def __fetch_pull_requests(self, from_date, to_date):
"""Fetch the pull requests"""
raw_pulls = self.client.pulls(from_date=from_date)
for raw_pull in raw_pulls:
pull = json.loads(raw_pull)
if str_to_datetime(pull['updated_at']) > to_date:
return
self.__init_extra_pull_fields(pull)
for field in TARGET_PULL_FIELDS:
if not pull[field]:
continue
| python | {
"resource": ""
} |
q269031 | GitHub.__fetch_repo_info | test | def __fetch_repo_info(self):
"""Get repo info about stars, watchers and forks"""
raw_repo = self.client.repo()
repo = json.loads(raw_repo)
| python | {
"resource": ""
} |
q269032 | GitHub.__get_issue_reactions | test | def __get_issue_reactions(self, issue_number, total_count):
"""Get issue reactions"""
reactions = []
if total_count == 0:
return reactions
group_reactions = self.client.issue_reactions(issue_number) | python | {
"resource": ""
} |
q269033 | GitHub.__get_issue_comment_reactions | test | def __get_issue_comment_reactions(self, comment_id, total_count):
"""Get reactions on issue comments"""
reactions = []
if total_count == 0:
return reactions
group_reactions = self.client.issue_comment_reactions(comment_id) | python | {
"resource": ""
} |
q269034 | GitHub.__get_issue_assignees | test | def __get_issue_assignees(self, raw_assignees):
"""Get issue assignees"""
assignees = []
for ra in raw_assignees:
| python | {
"resource": ""
} |
q269035 | GitHub.__get_pull_requested_reviewers | test | def __get_pull_requested_reviewers(self, pr_number):
"""Get pull request requested reviewers"""
requested_reviewers = []
group_requested_reviewers = self.client.pull_requested_reviewers(pr_number)
for raw_requested_reviewers in group_requested_reviewers: | python | {
"resource": ""
} |
q269036 | GitHub.__get_pull_commits | test | def __get_pull_commits(self, pr_number):
"""Get pull request commit hashes"""
hashes = []
group_pull_commits = self.client.pull_commits(pr_number)
for raw_pull_commits in group_pull_commits:
| python | {
"resource": ""
} |
q269037 | GitHub.__get_pull_review_comment_reactions | test | def __get_pull_review_comment_reactions(self, comment_id, total_count):
"""Get pull review comment reactions"""
reactions = []
if total_count == 0:
return reactions
group_reactions = self.client.pull_review_comment_reactions(comment_id) | python | {
"resource": ""
} |
q269038 | GitHub.__get_user | test | def __get_user(self, login):
"""Get user and org data for the login"""
user = {}
if not login:
return user
user_raw = self.client.user(login)
user = json.loads(user_raw)
user_orgs_raw = \
| python | {
"resource": ""
} |
q269039 | GitHubClient.issue_reactions | test | def issue_reactions(self, issue_number):
"""Get reactions of an issue"""
payload = {
'per_page': PER_PAGE,
'direction': 'asc',
'sort': 'updated'
| python | {
"resource": ""
} |
q269040 | GitHubClient.issues | test | def issues(self, from_date=None):
"""Fetch the issues from the repository.
The method retrieves, from a GitHub repository, the issues
updated since the given date.
:param from_date: obtain issues updated since this date
:returns: a generator of issues
"""
payload = {
'state': 'all',
'per_page': PER_PAGE,
| python | {
"resource": ""
} |
q269041 | GitHubClient.pulls | test | def pulls(self, from_date=None):
"""Fetch the pull requests from the repository.
The method retrieves, from a GitHub repository, the pull requests
updated since the given date.
:param from_date: obtain pull requests updated since this date
:returns: a generator of pull requests
"""
issues_groups = self.issues(from_date=from_date)
for raw_issues in issues_groups:
issues = json.loads(raw_issues)
for issue in issues:
if "pull_request" | python | {
"resource": ""
} |
q269042 | GitHubClient.repo | test | def repo(self):
"""Get repository data"""
path = urijoin(self.base_url, 'repos', self.owner, self.repository)
| python | {
"resource": ""
} |
q269043 | GitHubClient.pull_requested_reviewers | test | def pull_requested_reviewers(self, pr_number):
"""Get pull requested reviewers"""
requested_reviewers_url = | python | {
"resource": ""
} |
q269044 | GitHubClient.pull_commits | test | def pull_commits(self, pr_number):
"""Get pull request commits"""
payload = {
'per_page': PER_PAGE,
}
| python | {
"resource": ""
} |
q269045 | GitHubClient.pull_review_comment_reactions | test | def pull_review_comment_reactions(self, comment_id):
"""Get reactions of a review comment"""
payload = {
'per_page': PER_PAGE,
'direction': 'asc',
'sort': 'updated'
| python | {
"resource": ""
} |
q269046 | GitHubClient.user | test | def user(self, login):
"""Get the user information and update the user cache"""
user = None
if login in self._users:
return self._users[login]
url_user = urijoin(self.base_url, 'users', login)
| python | {
"resource": ""
} |
q269047 | GitHubClient.user_orgs | test | def user_orgs(self, login):
"""Get the user public organizations"""
if login in self._users_orgs:
return self._users_orgs[login]
url = urijoin(self.base_url, 'users', login, 'orgs')
try:
r = self.fetch(url)
| python | {
"resource": ""
} |
q269048 | GitHubClient._get_token_rate_limit | test | def _get_token_rate_limit(self, token):
"""Return token's remaining API points"""
rate_url = urijoin(self.base_url, "rate_limit")
self.session.headers.update({'Authorization': 'token ' + token})
remaining = 0
try:
headers = super().fetch(rate_url).headers
| python | {
"resource": ""
} |
q269049 | GitHubClient._get_tokens_rate_limits | test | def _get_tokens_rate_limits(self):
"""Return array of all tokens remaining API points"""
remainings = [0] * self.n_tokens
# Turn off archiving when checking rates, because that would cause
# archive key conflict (the same URLs giving different responses)
| python | {
"resource": ""
} |
q269050 | GitHubClient._choose_best_api_token | test | def _choose_best_api_token(self):
"""Check all API tokens defined and choose one with most remaining API points"""
# Return if no tokens given
if self.n_tokens == 0:
return
# If multiple tokens given, choose best
token_idx = 0
if self.n_tokens > 1:
remainings = self._get_tokens_rate_limits()
token_idx = remainings.index(max(remainings))
logger.debug("Remaining API points: {}, choosen index: {}".format(remainings, | python | {
"resource": ""
} |
q269051 | GitHubClient._need_check_tokens | test | def _need_check_tokens(self):
"""Check if we need to switch GitHub API tokens"""
if self.n_tokens <= 1 or self.rate_limit is None:
return False
elif self.last_rate_limit_checked is None:
self.last_rate_limit_checked = self.rate_limit
return True
# If approaching minimum rate limit for sleep
approaching_limit = float(self.min_rate_to_sleep) * (1.0 + TOKEN_USAGE_BEFORE_SWITCH) + 1
if self.rate_limit <= approaching_limit:
self.last_rate_limit_checked = self.rate_limit
return True
# Only switch token when used predefined factor of the current token's remaining API points
| python | {
"resource": ""
} |
q269052 | GitHubClient._update_current_rate_limit | test | def _update_current_rate_limit(self):
"""Update rate limits data for the current token"""
url = urijoin(self.base_url, "rate_limit")
try:
# Turn off archiving when checking rates, because that would cause
# archive key conflict (the same URLs giving different responses)
arch = self.archive
self.archive = None
response = super().fetch(url)
self.archive = arch
self.update_rate_limit(response) | python | {
"resource": ""
} |
q269053 | Archive.init_metadata | test | def init_metadata(self, origin, backend_name, backend_version,
category, backend_params):
"""Init metadata information.
Metatada is composed by basic information needed to identify
where archived data came from and how it can be retrieved
and built into Perceval items.
:param: origin: identifier of the repository
:param: backend_name: name of the backend
:param: backend_version: version of the backend
:param: category: category of the items fetched
:param: backend_params: dict representation of the fetch parameters
raises ArchiveError: when an error occurs initializing the metadata
"""
created_on = datetime_to_utc(datetime_utcnow())
created_on_dumped = created_on.isoformat()
backend_params_dumped = pickle.dumps(backend_params, 0)
metadata = (origin, backend_name, backend_version, category,
backend_params_dumped, created_on_dumped,)
try:
cursor = self._db.cursor()
insert_stmt = "INSERT INTO " + self.METADATA_TABLE + " "\
"(origin, backend_name, backend_version, " \
| python | {
"resource": ""
} |
q269054 | Archive.store | test | def store(self, uri, payload, headers, data):
"""Store a raw item in this archive.
The method will store `data` content in this archive. The unique
identifier for that item will be generated using the rest of the
parameters.
:param uri: request URI
:param payload: request payload
:param headers: request headers
:param data: data to store in this archive
:raises ArchiveError: when an error occurs storing the given data
"""
hashcode = self.make_hashcode(uri, payload, headers)
payload_dump = pickle.dumps(payload, 0)
headers_dump = pickle.dumps(headers, 0)
data_dump = pickle.dumps(data, 0)
logger.debug("Archiving %s with %s %s %s in %s",
hashcode, uri, payload, headers, self.archive_path)
try:
cursor = self._db.cursor()
insert_stmt = "INSERT INTO " + self.ARCHIVE_TABLE + " (" \
"id, hashcode, uri, payload, headers, data) " \
| python | {
"resource": ""
} |
q269055 | Archive.retrieve | test | def retrieve(self, uri, payload, headers):
"""Retrieve a raw item from the archive.
The method will return the `data` content corresponding to the
hascode derived from the given parameters.
:param uri: request URI
:param payload: request payload
:param headers: request headers
:returns: the archived data
:raises ArchiveError: when an error occurs retrieving data
"""
hashcode = self.make_hashcode(uri, payload, headers)
logger.debug("Retrieving entry %s with %s %s %s in %s",
hashcode, uri, payload, headers, self.archive_path)
self._db.row_factory = sqlite3.Row
try:
cursor = self._db.cursor()
select_stmt = "SELECT data " \
"FROM " + self.ARCHIVE_TABLE + " " \
| python | {
"resource": ""
} |
q269056 | Archive.create | test | def create(cls, archive_path):
"""Create a brand new archive.
Call this method to create a new and empty archive. It will initialize
the storage file in the path defined by `archive_path`.
:param archive_path: absolute path where the archive file will be created
:raises ArchiveError: when the archive file already exists
"""
if os.path.exists(archive_path):
msg = "archive %s already exists; remove it before creating a new one"
raise ArchiveError(cause=msg % (archive_path))
conn = sqlite3.connect(archive_path)
cursor = conn.cursor()
| python | {
"resource": ""
} |
q269057 | Archive.make_hashcode | test | def make_hashcode(uri, payload, headers):
"""Generate a SHA1 based on the given arguments.
Hashcodes created by this method will used as unique identifiers
for the raw items or resources stored by this archive.
:param uri: URI to the resource
:param payload: payload of the request | python | {
"resource": ""
} |
q269058 | Archive._verify_archive | test | def _verify_archive(self):
"""Check whether the archive is valid or not.
This method will check if tables were created and if they
contain valid data.
"""
nentries = self._count_table_rows(self.ARCHIVE_TABLE)
nmetadata = self._count_table_rows(self.METADATA_TABLE)
if nmetadata > 1:
msg = "archive %s metadata corrupted; multiple metadata entries" % (self.archive_path)
raise ArchiveError(cause=msg)
if nmetadata == 0 and nentries > 0:
msg = "archive %s metadata is | python | {
"resource": ""
} |
q269059 | Archive._load_metadata | test | def _load_metadata(self):
"""Load metadata from the archive file"""
logger.debug("Loading metadata infomation of archive %s", self.archive_path)
cursor = self._db.cursor()
select_stmt = "SELECT origin, backend_name, backend_version, " \
"category, backend_params, created_on " \
"FROM " + self.METADATA_TABLE + " " \
"LIMIT 1"
cursor.execute(select_stmt)
row = cursor.fetchone()
cursor.close()
if row:
| python | {
"resource": ""
} |
q269060 | Archive._count_table_rows | test | def _count_table_rows(self, table_name):
"""Fetch the number of rows in a table"""
cursor = self._db.cursor()
select_stmt = "SELECT COUNT(*) FROM " + table_name
try:
cursor.execute(select_stmt)
row = cursor.fetchone()
| python | {
"resource": ""
} |
q269061 | ArchiveManager.create_archive | test | def create_archive(self):
"""Create a new archive.
The method creates in the filesystem a brand new archive with
a random SHA1 as its name. The first byte of the hashcode will
be the name of the subdirectory; the remaining bytes, the
archive name.
:returns: a new `Archive` object
:raises ArchiveManagerError: when an error occurs creating the
new archive
"""
hashcode = uuid.uuid4().hex
archive_dir = os.path.join(self.dirpath, hashcode[0:2])
archive_name = hashcode[2:] + self.STORAGE_EXT
| python | {
"resource": ""
} |
q269062 | ArchiveManager.remove_archive | test | def remove_archive(self, archive_path):
"""Remove an archive.
This method deletes from the filesystem the archive stored
in `archive_path`.
:param archive_path: path to the archive
:raises ArchiveManangerError: when an error occurs removing the
archive
| python | {
"resource": ""
} |
q269063 | ArchiveManager.search | test | def search(self, origin, backend_name, category, archived_after):
"""Search archives.
Get the archives which store data based on the given parameters.
These parameters define which the origin was (`origin`), how data
was fetched (`backend_name`) and data type ('category').
Only those archives created on or after `archived_after` will be
returned.
The method returns a list with the file paths to those archives.
The list is sorted by the date of creation of each archive.
:param origin: data origin
:param backend_name: backed used to fetch data
:param category: type of the items fetched by the backend
| python | {
"resource": ""
} |
q269064 | ArchiveManager._search_archives | test | def _search_archives(self, origin, backend_name, category, archived_after):
"""Search archives using filters."""
for archive_path in self._search_files():
try:
archive = Archive(archive_path)
except ArchiveError:
continue
match = archive.origin == origin and \
archive.backend_name == backend_name and \
| python | {
"resource": ""
} |
q269065 | ArchiveManager._search_files | test | def _search_files(self):
"""Retrieve the file paths stored under the base path."""
for root, _, files in os.walk(self.dirpath):
for filename | python | {
"resource": ""
} |
q269066 | check_compressed_file_type | test | def check_compressed_file_type(filepath):
"""Check if filename is a compressed file supported by the tool.
This function uses magic numbers (first four bytes) to determine
the type of the file. Supported types are 'gz' and 'bz2'. When
the filetype is not supported, the function returns `None`.
:param filepath: path to the file
:returns: 'gz' or 'bz2'; `None` if the type is not supported
"""
def compressed_file_type(content):
magic_dict = {
b'\x1f\x8b\x08': 'gz',
b'\x42\x5a\x68': 'bz2',
| python | {
"resource": ""
} |
q269067 | months_range | test | def months_range(from_date, to_date):
"""Generate a months range.
Generator of months starting on `from_date` util `to_date`. Each
returned item is a tuple of two datatime objects like in (month, month+1).
Thus, the result will follow the sequence:
((fd, fd+1), (fd+1, fd+2), ..., (td-2, td-1), (td-1, td))
:param from_date: generate dates starting on this month
:param to_date: generate dates until this month
:result: a generator of months range
"""
| python | {
"resource": ""
} |
q269068 | message_to_dict | test | def message_to_dict(msg):
"""Convert an email message into a dictionary.
This function transforms an `email.message.Message` object
into a dictionary. Headers are stored as key:value pairs
while the body of the message is stored inside `body` key.
Body may have two other keys inside, 'plain', for plain body
messages and 'html', for HTML encoded messages.
The returned dictionary has the type `requests.structures.CaseInsensitiveDict`
due to same headers with different case formats can appear in
the same message.
:param msg: email message of type `email.message.Message`
:returns : dictionary of type `requests.structures.CaseInsensitiveDict`
:raises ParseError: when an error occurs transforming the message
to a dictionary
"""
def parse_headers(msg):
headers = {}
for header, value in msg.items():
hv = []
for text, charset in email.header.decode_header(value):
if type(text) == bytes:
charset = charset if charset else 'utf-8'
try:
text = text.decode(charset, errors='surrogateescape')
except (UnicodeError, LookupError):
# Try again with a 7bit encoding
text = text.decode('ascii', errors='surrogateescape')
hv.append(text)
v = ' '.join(hv)
headers[header] = v if v else None
return headers
def parse_payload(msg):
body = {}
if not msg.is_multipart():
payload = decode_payload(msg)
subtype = msg.get_content_subtype()
body[subtype] = [payload]
else:
# Include all the attached texts if it is multipart
# Ignores binary parts by default
for part in email.iterators.typed_subpart_iterator(msg):
payload = decode_payload(part)
| python | {
"resource": ""
} |
q269069 | remove_invalid_xml_chars | test | def remove_invalid_xml_chars(raw_xml):
"""Remove control and invalid characters from an xml stream.
Looks for invalid characters and subtitutes them with whitespaces.
This solution is based on these two posts: Olemis Lang's reponse
on StackOverflow (http://stackoverflow.com/questions/1707890) and
lawlesst's on GitHub Gist (https://gist.github.com/lawlesst/4110923),
that is based on the previous answer.
:param xml: XML stream
:returns: a purged XML stream
"""
illegal_unichrs = [(0x00, 0x08), (0x0B, 0x1F),
(0x7F, 0x84), (0x86, 0x9F)]
illegal_ranges | python | {
"resource": ""
} |
q269070 | xml_to_dict | test | def xml_to_dict(raw_xml):
"""Convert a XML stream into a dictionary.
This function transforms a xml stream into a dictionary. The
attributes are stored as single elements while child nodes are
stored into lists. The text node is stored using the special
key '__text__'.
This code is based on Winston Ewert's solution to this problem.
See http://codereview.stackexchange.com/questions/10400/convert-elementtree-to-dict
for more info. The code was licensed as cc by-sa 3.0.
:param raw_xml: XML stream
:returns: a dict with the XML data
:raises ParseError: raised when an error occurs parsing the given
XML stream
"""
def node_to_dict(node):
d = {}
d.update(node.items())
text = getattr(node, 'text', None)
if text is not None:
d['__text__'] = text
childs = {}
for child in node:
| python | {
"resource": ""
} |
q269071 | Redmine.parse_issues | test | def parse_issues(raw_json):
"""Parse a Redmine issues JSON stream.
The method parses a JSON stream and returns a list iterator.
Each item is a dictionary that contains the issue parsed data.
:param raw_json: JSON string to parse
:returns: a generator of parsed issues
| python | {
"resource": ""
} |
q269072 | RedmineClient.issues | test | def issues(self, from_date=DEFAULT_DATETIME,
offset=None, max_issues=MAX_ISSUES):
"""Get the information of a list of issues.
:param from_date: retrieve issues that where updated from that date;
dates are converted to UTC
:param offset: starting position for the search
:param max_issues: maximum number of issues to reteurn per query
"""
resource = self.RISSUES + self.CJSON
ts = datetime_to_utc(from_date)
ts = ts.strftime("%Y-%m-%dT%H:%M:%SZ")
# By default, Redmine returns open issues only.
# Parameter 'status_id' is set | python | {
"resource": ""
} |
q269073 | RedmineClient.issue | test | def issue(self, issue_id):
"""Get the information of the given issue.
:param issue_id: issue identifier
"""
resource = urijoin(self.RISSUES, str(issue_id) + self.CJSON)
params = {
self.PINCLUDE: ','.join([self.CATTACHMENTS, self.CCHANGESETS,
| python | {
"resource": ""
} |
q269074 | RedmineClient.user | test | def user(self, user_id):
"""Get the information of the given user.
:param user_id: user identifier
| python | {
"resource": ""
} |
q269075 | RedmineClient._call | test | def _call(self, resource, params):
"""Call to get a resource.
:param method: resource to get
:param params: dict with the HTTP parameters needed to get
the given resource
"""
url = self.URL % {'base': self.base_url, 'resource': resource}
if self.api_token:
| python | {
"resource": ""
} |
q269076 | DockerHub.fetch | test | def fetch(self, category=CATEGORY_DOCKERHUB_DATA):
"""Fetch data from a Docker Hub repository.
The method retrieves, from a repository stored in Docker Hub,
its data which includes number of pulls, stars, description,
among other data.
:param category: the category of items to fetch
| python | {
"resource": ""
} |
q269077 | DockerHub.fetch_items | test | def fetch_items(self, category, **kwargs):
"""Fetch the Dockher Hub items
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
logger.info("Fetching data from '%s' repository of '%s' owner",
self.repository, self.owner)
| python | {
"resource": ""
} |
q269078 | DockerHubClient.repository | test | def repository(self, owner, repository):
"""Fetch information about a repository."""
url = urijoin(self.base_url, self.RREPOSITORY, owner, repository)
| python | {
"resource": ""
} |
q269079 | map_custom_field | test | def map_custom_field(custom_fields, fields):
"""Add extra information for custom fields.
:param custom_fields: set of custom fields with the extra information
:param fields: fields of the issue where to add the extra information
:returns: an set of items with the extra information mapped
"""
def build_cf(cf, v):
| python | {
"resource": ""
} |
q269080 | filter_custom_fields | test | def filter_custom_fields(fields):
"""Filter custom fields from a given set of fields.
:param fields: set of fields
:returns: an object with the filtered custom fields
"""
custom_fields = {}
| python | {
"resource": ""
} |
q269081 | Jira.parse_issues | test | def parse_issues(raw_page):
"""Parse a JIRA API raw response.
The method parses the API response retrieving the
issues from the received items
:param items: items from where to parse the issues
:returns: a generator of issues
| python | {
"resource": ""
} |
q269082 | JiraClient.get_items | test | def get_items(self, from_date, url, expand_fields=True):
"""Retrieve all the items from a given date.
:param url: endpoint API url
:param from_date: obtain items updated since this date
:param expand_fields: if True, it includes the expand fields in the payload
"""
start_at = 0
req = self.fetch(url, payload=self.__build_payload(start_at, from_date, expand_fields))
issues = req.text
data = req.json()
titems = data['total']
nitems = data['maxResults']
start_at += min(nitems, titems)
self.__log_status(start_at, titems, url)
| python | {
"resource": ""
} |
q269083 | JiraClient.get_issues | test | def get_issues(self, from_date):
"""Retrieve all the issues from a given date.
:param from_date: obtain issues updated since this date
"""
| python | {
"resource": ""
} |
q269084 | JiraClient.get_comments | test | def get_comments(self, issue_id):
"""Retrieve all the comments of a given issue.
:param issue_id: ID of the issue
"""
| python | {
"resource": ""
} |
q269085 | JiraClient.get_fields | test | def get_fields(self):
"""Retrieve all the fields available."""
url = urijoin(self.base_url, self.RESOURCE, self.VERSION_API, | python | {
"resource": ""
} |
q269086 | Jenkins.fetch | test | def fetch(self, category=CATEGORY_BUILD):
"""Fetch the builds from the url.
The method retrieves, from a Jenkins url, the
builds updated since the | python | {
"resource": ""
} |
q269087 | JenkinsClient.get_jobs | test | def get_jobs(self):
""" Retrieve all jobs"""
url_jenkins = urijoin(self.base_url, "api", "json")
| python | {
"resource": ""
} |
q269088 | JenkinsClient.get_builds | test | def get_builds(self, job_name):
""" Retrieve all builds from a job"""
if self.blacklist_jobs and job_name in self.blacklist_jobs:
logger.warning("Not getting blacklisted job: %s", job_name)
return
payload = {'depth': self.detail_depth}
| python | {
"resource": ""
} |
q269089 | StackExchange.parse_questions | test | def parse_questions(raw_page):
"""Parse a StackExchange API raw response.
The method parses the API response retrieving the
questions from the received items
:param items: items from where to parse the questions
:returns: a generator of questions
| python | {
"resource": ""
} |
q269090 | StackExchangeClient.get_questions | test | def get_questions(self, from_date):
"""Retrieve all the questions from a given date.
:param from_date: obtain questions updated since this date
"""
page = 1
url = urijoin(self.base_url, self.VERSION_API, "questions")
req = self.fetch(url, payload=self.__build_payload(page, from_date))
questions = req.text
data = req.json()
tquestions = data['total']
nquestions = data['page_size']
self.__log_status(data['quota_remaining'],
data['quota_max'],
nquestions,
tquestions)
while questions:
yield questions
questions = None
if data['has_more']:
page += 1
backoff = data.get('backoff', None)
| python | {
"resource": ""
} |
q269091 | StackExchangeCommand.setup_cmd_parser | test | def setup_cmd_parser(cls):
"""Returns the StackExchange argument parser."""
parser = BackendCommandArgumentParser(cls.BACKEND.CATEGORIES,
from_date=True,
token_auth=True,
archive=True)
# StackExchange options
group = parser.parser.add_argument_group('StackExchange arguments')
group.add_argument('--site', dest='site',
required=True,
help="StackExchange site")
| python | {
"resource": ""
} |
q269092 | MediaWiki.fetch_items | test | def fetch_items(self, category, **kwargs):
"""Fetch the pages
:param category: the category of items to fetch
:param kwargs: backend arguments
:returns: a generator of items
"""
from_date = kwargs['from_date']
reviews_api = kwargs['reviews_api']
mediawiki_version = self.client.get_version()
logger.info("MediaWiki version: %s", mediawiki_version)
if reviews_api:
if ((mediawiki_version[0] == 1 and mediawiki_version[1] >= 27) or mediawiki_version[0] > 1):
fetcher = self.__fetch_1_27(from_date)
else:
| python | {
"resource": ""
} |
q269093 | MediaWiki.__get_max_date | test | def __get_max_date(self, reviews):
""""Get the max date in unixtime format from reviews."""
max_ts = 0
for review in reviews: | python | {
"resource": ""
} |
q269094 | MediaWiki.__fetch_1_27 | test | def __fetch_1_27(self, from_date=None):
"""Fetch the pages from the backend url for MediaWiki >=1.27
The method retrieves, from a MediaWiki url, the
wiki pages.
:returns: a generator of pages
"""
logger.info("Looking for pages at url '%s'", self.url)
npages = 0 # number of pages processed
tpages = 0 # number of total pages
pages_done = [] # pages already retrieved in reviews API
namespaces_contents = self.__get_namespaces_contents()
arvcontinue = '' # pagination for getting revisions and their pages
while arvcontinue is not None:
raw_pages = self.client.get_pages_from_allrevisions(namespaces_contents, from_date, arvcontinue)
data_json = json.loads(raw_pages)
arvcontinue = data_json['continue']['arvcontinue'] if 'continue' in data_json else None
pages_json = data_json['query']['allrevisions']
for page in pages_json:
if page['pageid'] in pages_done:
logger.debug("Page %s already processed; skipped", page['pageid'])
continue
| python | {
"resource": ""
} |
q269095 | MediaWikiClient.get_pages | test | def get_pages(self, namespace, apcontinue=''):
"""Retrieve all pages from a namespace starting from apcontinue."""
params = {
"action": "query",
"list": "allpages",
"aplimit": self.limit,
| python | {
"resource": ""
} |
q269096 | MediaWikiClient.get_recent_pages | test | def get_recent_pages(self, namespaces, rccontinue=''):
"""Retrieve recent pages from all namespaces starting from rccontinue."""
namespaces.sort()
params = {
"action": "query",
"list": "recentchanges",
"rclimit": self.limit,
| python | {
"resource": ""
} |
q269097 | Telegram.fetch | test | def fetch(self, category=CATEGORY_MESSAGE, offset=DEFAULT_OFFSET, chats=None):
"""Fetch the messages the bot can read from the server.
The method retrieves, from the Telegram server, the messages
sent with an offset equal or greater than the given.
A list of chats, groups and channels identifiers can be set
using the parameter `chats`. When it is set, only those
messages sent to any of these will be returned. An empty list
will return no messages.
:param category: the category of items to fetch
:param offset: obtain messages from this offset
| python | {
"resource": ""
} |
q269098 | Telegram.parse_messages | test | def parse_messages(raw_json):
"""Parse a Telegram JSON messages list.
The method parses the JSON stream and returns an iterator of
dictionaries. Each one of this, contains a Telegram message.
:param raw_json: JSON string to parse
:returns: a generator of parsed messages
| python | {
"resource": ""
} |
q269099 | Telegram._filter_message_by_chats | test | def _filter_message_by_chats(self, message, chats):
"""Check if a message can be filtered based in a list of chats.
This method returns `True` when the message was sent to a chat
of the given list. It also returns `True` when chats is `None`.
:param message: Telegram message
:param chats: list of chat, groups and channels identifiers
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.