_id stringlengths 2 6 | title stringlengths 9 130 | partition stringclasses 3
values | text stringlengths 66 10.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q26500 | Barby.Code93.c_checksum | test | def c_checksum
sum = 0
checksum_values.each_with_index do |value, index|
sum += ((index % 20) + 1) * value
end
sum % 47
end | ruby | {
"resource": ""
} |
q26501 | Barby.Code93.k_checksum | test | def k_checksum
sum = 0
checksum_values_with_c_checksum.each_with_index do |value, index|
sum += ((index % 15) + 1) * value
end
sum % 47
end | ruby | {
"resource": ""
} |
q26502 | Barby.PDFWriterOutputter.annotate_pdf | test | def annotate_pdf(pdf, options={})
with_options options do
xpos, ypos = x, y
orig_xpos = xpos
if barcode.two_dimensional?
boolean_groups.reverse_each do |groups|
groups.each do |bar,amount|
if bar
pdf.move_to(xpos, ypos).
... | ruby | {
"resource": ""
} |
q26503 | Barby.Code39.characters | test | def characters
chars = raw_characters
extended ? chars.map{|c| EXTENDED_ENCODINGS[c].split(//) }.flatten : chars
end | ruby | {
"resource": ""
} |
q26504 | Barby.Code128.characters | test | def characters
chars = data.split(//n)
if type == 'C'
result = []
count = 0
while count < chars.size
if chars[count] =~ /^\d$/
#If encountering a digit, next char/byte *must* be second digit in pair. I.e. if chars[count] is 5,
#chars[count+1] must b... | ruby | {
"resource": ""
} |
q26505 | Barby.Code128.checksum | test | def checksum
pos = 0
(numbers+extra_numbers).inject(start_num) do |sum,number|
pos += 1
sum + (number * pos)
end % 103
end | ruby | {
"resource": ""
} |
q26506 | Barby.Code25.encoding_for_bars | test | def encoding_for_bars(*bars)
wide, narrow, space = wide_encoding, narrow_encoding, space_encoding
bars.flatten.inject '' do |enc,bar|
enc + (bar == WIDE ? wide : narrow) + space
end
end | ruby | {
"resource": ""
} |
q26507 | Barby.CairoOutputter.render_to_cairo_context | test | def render_to_cairo_context(context, options={})
if context.respond_to?(:have_current_point?) and
context.have_current_point?
current_x, current_y = context.current_point
else
current_x = x(options) || margin(options)
current_y = y(options) || margin(options)
end
... | ruby | {
"resource": ""
} |
q26508 | Barby.CairoOutputter.to_png | test | def to_png(options={})
output_to_string_io do |io|
Cairo::ImageSurface.new(options[:format],
full_width(options),
full_height(options)) do |surface|
render(surface, options)
surface.write_to_png(io)
end
end
... | ruby | {
"resource": ""
} |
q26509 | Barby.CairoOutputter.to_ps | test | def to_ps(options={})
output_to_string_io do |io|
Cairo::PSSurface.new(io,
full_width(options),
full_height(options)) do |surface|
surface.eps = options[:eps] if surface.respond_to?(:eps=)
render(surface, options)
end
... | ruby | {
"resource": ""
} |
q26510 | Barby.CairoOutputter.to_pdf | test | def to_pdf(options={})
output_to_string_io do |io|
Cairo::PDFSurface.new(io,
full_width(options),
full_height(options)) do |surface|
render(surface, options)
end
end
end | ruby | {
"resource": ""
} |
q26511 | Barby.CairoOutputter.to_svg | test | def to_svg(options={})
output_to_string_io do |io|
Cairo::SVGSurface.new(io,
full_width(options),
full_height(options)) do |surface|
render(surface, options)
end
end
end | ruby | {
"resource": ""
} |
q26512 | CMSScanner.Browser.max_threads= | test | def max_threads=(number)
@max_threads = number.to_i.positive? && throttle.zero? ? number.to_i : 1
hydra.max_concurrency = @max_threads
end | ruby | {
"resource": ""
} |
q26513 | CMSScanner.WebSite.online? | test | def online?(path = nil)
NS::Browser.get(url(path)).code.nonzero? ? true : false
end | ruby | {
"resource": ""
} |
q26514 | CMSScanner.WebSite.head_and_get | test | def head_and_get(path, codes = [200], params = {})
url_to_get = url(path)
head_params = (params[:head] || {}).merge(head_or_get_params)
head_res = NS::Browser.forge_request(url_to_get, head_params).run
codes.include?(head_res.code) ? NS::Browser.get(url_to_get, params[:get] || {}) : head_res
... | ruby | {
"resource": ""
} |
q26515 | GHTorrent.Mirror.db | test | def db
return @db unless @db.nil?
Sequel.single_threaded = true
@db = Sequel.connect(config(:sql_url), :encoding => 'utf8')
#@db.loggers << Logger.new(STDOUT)
if @db.tables.empty?
dir = File.join(File.dirname(__FILE__), 'migrations')
puts "Database empty, running migration... | ruby | {
"resource": ""
} |
q26516 | GHTorrent.Mirror.ensure_commit | test | def ensure_commit(repo, sha, user, comments = true)
ensure_repo(user, repo)
c = retrieve_commit(repo, sha, user)
if c.nil?
warn "Commit #{user}/#{repo} -> #{sha} does not exist"
return
end
stored = store_commit(c, repo, user)
ensure_parents(c)
if not c['commit... | ruby | {
"resource": ""
} |
q26517 | GHTorrent.Mirror.ensure_parents | test | def ensure_parents(commit)
commits = db[:commits]
parents = db[:commit_parents]
commit['parents'].map do |p|
save do
url = p['url'].split(/\//)
this = commits.first(:sha => commit['sha'])
parent = commits.first(:sha => url[7])
if parent.nil?
... | ruby | {
"resource": ""
} |
q26518 | GHTorrent.Mirror.ensure_user_followers | test | def ensure_user_followers(followed)
curuser = ensure_user(followed, false, false)
followers = db.from(:followers, :users).\
where(Sequel.qualify('followers', 'follower_id') => Sequel.qualify('users', 'id')).\
where(Sequel.qualify('followers', 'user_id') => curuser[:id]).select(:login).al... | ruby | {
"resource": ""
} |
q26519 | GHTorrent.Mirror.ensure_user_follower | test | def ensure_user_follower(followed, follower, date_added = nil)
follower_user = ensure_user(follower, false, false)
followed_user = ensure_user(followed, false, false)
if followed_user.nil? or follower_user.nil?
warn "Could not find follower #{follower} or user #{followed}"
return
... | ruby | {
"resource": ""
} |
q26520 | GHTorrent.Mirror.ensure_user_byemail | test | def ensure_user_byemail(email, name)
users = db[:users]
usr = users.first(:email => email)
if usr.nil?
u = retrieve_user_byemail(email, name)
if u.nil? or u['login'].nil?
warn "Could not retrieve user #{email} through search API query"
login = (0...8).map { 65.+(... | ruby | {
"resource": ""
} |
q26521 | GHTorrent.Mirror.ensure_repo | test | def ensure_repo(user, repo, recursive = false)
repos = db[:projects]
curuser = ensure_user(user, false, false)
if curuser.nil?
warn "Could not find user #{user}"
return
end
currepo = repos.first(:owner_id => curuser[:id], :name => repo)
unless currepo.nil?
... | ruby | {
"resource": ""
} |
q26522 | GHTorrent.Mirror.ensure_languages | test | def ensure_languages(owner, repo)
currepo = ensure_repo(owner, repo)
langs = retrieve_languages(owner, repo)
if langs.nil? or langs.empty?
warn "Could not find languages for repo #{owner}/#{repo}"
return
end
ts = Time.now
langs.keys.each do |lang|
db[:projec... | ruby | {
"resource": ""
} |
q26523 | GHTorrent.Mirror.ensure_fork_commits | test | def ensure_fork_commits(owner, repo, parent_owner, parent_repo)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find repo #{owner}/#{repo}"
return
end
parent = ensure_repo(parent_owner, parent_repo)
if parent.nil?
warn "Could not find repo #{p... | ruby | {
"resource": ""
} |
q26524 | GHTorrent.Mirror.ensure_fork_point | test | def ensure_fork_point(owner, repo)
fork = ensure_repo(owner, repo, false)
if fork[:forked_from].nil?
warn "Repo #{owner}/#{repo} is not a fork"
return nil
end
# Return commit if already specified
unless fork[:forked_commit_id].nil?
commit = db[:commits].where(:id... | ruby | {
"resource": ""
} |
q26525 | GHTorrent.Mirror.ensure_orgs | test | def ensure_orgs(user)
retrieve_orgs(user).map{|o| save{ensure_participation(user, o['login'])}}.select{|x| !x.nil?}
end | ruby | {
"resource": ""
} |
q26526 | GHTorrent.Mirror.ensure_participation | test | def ensure_participation(user, organization, members = true)
org = ensure_org(organization, members)
if org.nil?
warn "Could not find organization #{organization}"
return
end
usr = ensure_user(user, false, false)
org_members = db[:organization_members]
participates... | ruby | {
"resource": ""
} |
q26527 | GHTorrent.Mirror.ensure_org | test | def ensure_org(organization, members = true)
org = db[:users].first(:login => organization, :type => 'org')
if org.nil?
org = ensure_user(organization, false, false)
# Not an organization, don't go ahead
if org[:type] != 'ORG'
warn "User #{organization} is not an organiza... | ruby | {
"resource": ""
} |
q26528 | GHTorrent.Mirror.ensure_commit_comments | test | def ensure_commit_comments(user, repo, sha)
commit_id = db[:commits].first(:sha => sha)[:id]
stored_comments = db[:commit_comments].filter(:commit_id => commit_id)
commit_comments = retrieve_commit_comments(user, repo, sha)
not_saved = commit_comments.reduce([]) do |acc, x|
if stored_co... | ruby | {
"resource": ""
} |
q26529 | GHTorrent.Mirror.ensure_watchers | test | def ensure_watchers(owner, repo)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find repo #{owner}/#{repo} for retrieving watchers"
return
end
watchers = db.from(:watchers, :users).\
where(Sequel.qualify('watchers', 'user_id') => Sequel.qualify('us... | ruby | {
"resource": ""
} |
q26530 | GHTorrent.Mirror.ensure_pull_requests | test | def ensure_pull_requests(owner, repo, refresh = false)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find repo #{owner}/#{repo} for retrieving pull requests"
return
end
raw_pull_reqs = if refresh
retrieve_pull_requests(owner, repo, re... | ruby | {
"resource": ""
} |
q26531 | GHTorrent.Mirror.ensure_pull_request_history | test | def ensure_pull_request_history(id, ts, act, actor)
user = unless actor.nil?
ensure_user(actor, false, false)
end
pull_req_history = db[:pull_request_history]
entry = if ['opened', 'merged'].include? act
pull_req_history.first(:pull_request_id => id,
... | ruby | {
"resource": ""
} |
q26532 | GHTorrent.Mirror.pr_is_intra_branch | test | def pr_is_intra_branch(req)
return false unless pr_has_head_repo(req)
if req['head']['repo']['owner']['login'] ==
req['base']['repo']['owner']['login'] and
req['head']['repo']['full_name'] == req['base']['repo']['full_name']
true
else
false
end
end | ruby | {
"resource": ""
} |
q26533 | GHTorrent.Mirror.ensure_forks | test | def ensure_forks(owner, repo)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find repo #{owner}/#{repo} for retrieving forks"
return
end
existing_forks = db.from(:projects, :users).\
where(Sequel.qualify('users', 'id') => Sequel.qualify('projects',... | ruby | {
"resource": ""
} |
q26534 | GHTorrent.Mirror.ensure_fork | test | def ensure_fork(owner, repo, fork_id)
fork = retrieve_fork(owner, repo, fork_id)
if fork.nil?
warn "Could not retrieve fork #{owner}/#{repo} -> #{fork_id}"
return
end
fork_name = if fork['full_name'].nil? then fork['url'].split(/\//)[4..5].join('/') else fork['full_name'] end
... | ruby | {
"resource": ""
} |
q26535 | GHTorrent.Mirror.ensure_issues | test | def ensure_issues(owner, repo)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find repo #{owner}/#{repo} for retrieving issues"
return
end
issues = db[:issues].filter(:repo_id => currepo[:id]).all
raw_issues = retrieve_issues(owner, repo).reduce([]) do ... | ruby | {
"resource": ""
} |
q26536 | GHTorrent.Mirror.ensure_issue | test | def ensure_issue(owner, repo, issue_id, events = true,
comments = true, labels = true)
issues = db[:issues]
repository = ensure_repo(owner, repo)
if repository.nil?
warn "Could not find repo #{owner}/#{repo} for retrieving issue #{issue_id}"
return
end
... | ruby | {
"resource": ""
} |
q26537 | GHTorrent.Mirror.ensure_issue_events | test | def ensure_issue_events(owner, repo, issue_id)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find repository #{owner}/#{repo} for retrieving events for issue #{issue_id}"
return
end
issue = ensure_issue(owner, repo, issue_id, false, false, false)
if i... | ruby | {
"resource": ""
} |
q26538 | GHTorrent.Mirror.ensure_issue_event | test | def ensure_issue_event(owner, repo, issue_id, event_id)
issue = ensure_issue(owner, repo, issue_id, false, false, false)
if issue.nil?
warn "Could not find issue #{owner}/#{repo} -> #{issue_id} for retrieving event #{event_id}"
return
end
issue_event_str = "#{owner}/#{repo} -> ... | ruby | {
"resource": ""
} |
q26539 | GHTorrent.Mirror.ensure_issue_comments | test | def ensure_issue_comments(owner, repo, issue_id, pull_req_id = nil)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find repository #{owner}/#{repo} for retrieving issue comments for issue #{issue_id}"
return
end
issue = if pull_req_id.nil?
en... | ruby | {
"resource": ""
} |
q26540 | GHTorrent.Mirror.ensure_issue_comment | test | def ensure_issue_comment(owner, repo, issue_id, comment_id, pull_req_id = nil)
issue = if pull_req_id.nil?
ensure_issue(owner, repo, issue_id, false, false, false)
else
db[:issues].first(:pull_request_id => pull_req_id)
end
if issue.nil?
w... | ruby | {
"resource": ""
} |
q26541 | GHTorrent.Mirror.ensure_labels | test | def ensure_labels(owner, repo)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find #{owner}/#{repo} for retrieving issue labels"
return
end
repo_labels = db[:repo_labels].filter(:repo_id => currepo[:id]).all
retrieve_repo_labels(owner, repo).reduce([]... | ruby | {
"resource": ""
} |
q26542 | GHTorrent.Mirror.ensure_repo_label | test | def ensure_repo_label(owner, repo, name)
currepo = ensure_repo(owner, repo)
if currepo.nil?
warn "Could not find #{owner}/#{repo} for retrieving label #{name}"
return
end
label = db[:repo_labels].first(:repo_id => currepo[:id], :name => name)
if label.nil?
retrie... | ruby | {
"resource": ""
} |
q26543 | GHTorrent.Mirror.ensure_issue_labels | test | def ensure_issue_labels(owner, repo, issue_id)
issue = ensure_issue(owner, repo, issue_id, false, false, false)
if issue.nil?
warn "Could not find issue #{owner}/#{repo} -> #{issue_id} for retrieving labels"
return
end
issue_labels = db.from(:issue_labels, :repo_labels)\
... | ruby | {
"resource": ""
} |
q26544 | GHTorrent.Mirror.ensure_issue_label | test | def ensure_issue_label(owner, repo, issue_id, name)
issue = ensure_issue(owner, repo, issue_id, false, false, false)
if issue.nil?
warn "Could not find issue #{owner}/#{repo} -> #{issue_id} to assign label #{name}"
return
end
label = ensure_repo_label(owner, repo, name)
... | ruby | {
"resource": ""
} |
q26545 | GHTorrent.Mirror.transaction | test | def transaction(&block)
db
persister
result = nil
start_time = Time.now
begin
db.transaction(:rollback => :reraise, :isolation => :repeatable,
:retry_on => @retry_on_error, :num_retries => 3) do
result = yield block
end
total = Tim... | ruby | {
"resource": ""
} |
q26546 | GHTorrent.Mirror.store_commit | test | def store_commit(c, repo, user)
commits = db[:commits]
commit = commits.first(:sha => c['sha'])
if commit.nil?
author = commit_user(c['author'], c['commit']['author'])
commiter = commit_user(c['committer'], c['commit']['committer'])
repository = ensure_repo(user, repo)
... | ruby | {
"resource": ""
} |
q26547 | GHTorrent.Logging.log | test | def log(level, msg)
case level
when :fatal then
loggerr.fatal (retrieve_caller + msg)
when :error then
loggerr.error (retrieve_caller + msg)
when :warn then
loggerr.warn (retrieve_caller + msg)
when :info then
loggerr.info (retrieve_caller... | ruby | {
"resource": ""
} |
q26548 | GHTorrent.APIClient.paged_api_request | test | def paged_api_request(url, pages = config(:mirror_history_pages_back),
last = nil)
url = ensure_max_per_page(url)
data = api_request_raw(url)
return [] if data.nil?
unless data.meta['link'].nil?
links = parse_links(data.meta['link'])
last = links['las... | ruby | {
"resource": ""
} |
q26549 | GHTorrent.APIClient.last_updated | test | def last_updated(url, etag)
begin
ts = Time.now
response = do_request(url, '', etag)
info "Successful etag request. URL: #{url}, Etag: #{etag}, Remaining: #{@remaining}, Total: #{Time.now.to_ms - ts.to_ms} ms"
rescue OpenURI::HTTPError => e
response = e.io
if response... | ruby | {
"resource": ""
} |
q26550 | GHTorrent.APIClient.num_pages | test | def num_pages(url)
url = ensure_max_per_page(url)
data = api_request_raw(url)
if data.nil? or data.meta.nil? or data.meta['link'].nil?
return 1
end
links = parse_links(data.meta['link'])
if links.nil? or links['last'].nil?
return 1
end
params = CGI::pa... | ruby | {
"resource": ""
} |
q26551 | GHTorrent.APIClient.parse_links | test | def parse_links(links)
links.split(/,/).reduce({}) do |acc, x|
matches = x.strip.match(/<(.*)>; rel=\"(.*)\"/)
acc[matches[2]] = matches[1]
acc
end
end | ruby | {
"resource": ""
} |
q26552 | GHTorrent.APIClient.parse_request_result | test | def parse_request_result(result)
if result.nil?
[]
else
json = result.read
if json.nil?
[]
else
r = JSON.parse(json)
# Add the etag to the response only for individual entities
if result.meta['etag'] and r.class != Array
r... | ruby | {
"resource": ""
} |
q26553 | GHTorrent.APIClient.api_request_raw | test | def api_request_raw(url, media_type = '')
begin
start_time = Time.now
contents = do_request(url, media_type)
total = Time.now.to_ms - start_time.to_ms
info "Successful request. URL: #{url}, Remaining: #{@remaining}, Total: #{total} ms"
contents
rescue OpenURI::HTTP... | ruby | {
"resource": ""
} |
q26554 | GHTorrent.APIClient.attach_to | test | def attach_to(ip)
TCPSocket.instance_eval do
(class << self; self; end).instance_eval do
alias_method :original_open, :open
case RUBY_VERSION
when /1.8/, /1.9/
define_method(:open) do |conn_address, conn_port|
original_open(conn_address, conn_... | ruby | {
"resource": ""
} |
q26555 | GHTorrent.Persister.connect | test | def connect(adapter, settings)
driver = ADAPTERS[adapter.intern]
driver.new(settings)
end | ruby | {
"resource": ""
} |
q26556 | GHTorrent.Retriever.retrieve_commit | test | def retrieve_commit(repo, sha, user)
commit = persister.find(:commits, {'sha' => "#{sha}"})
if commit.empty?
url = ghurl "repos/#{user}/#{repo}/commits/#{sha}"
c = api_request(url)
if c.nil? or c.empty?
return
end
# commit patches are big and not always i... | ruby | {
"resource": ""
} |
q26557 | GHTorrent.Retriever.retrieve_commits | test | def retrieve_commits(repo, sha, user, pages = -1)
url = if sha.nil?
ghurl "repos/#{user}/#{repo}/commits"
else
ghurl "repos/#{user}/#{repo}/commits?sha=#{sha}"
end
commits = restricted_page_request(url, pages)
commits.map do |c|
retrieve_c... | ruby | {
"resource": ""
} |
q26558 | GHTorrent.Retriever.retrieve_orgs | test | def retrieve_orgs(user)
url = ghurl "users/#{user}/orgs"
orgs = paged_api_request(url)
orgs.map{|o| retrieve_org(o['login'])}
end | ruby | {
"resource": ""
} |
q26559 | GHTorrent.Retriever.retrieve_watchers | test | def retrieve_watchers(user, repo)
repo_bound_items(user, repo, :watchers,
["repos/#{user}/#{repo}/stargazers"],
{'repo' => repo, 'owner' => user},
'login', item = nil, refresh = false, order = :desc)
end | ruby | {
"resource": ""
} |
q26560 | GHTorrent.Retriever.retrieve_watcher | test | def retrieve_watcher(user, repo, watcher)
repo_bound_item(user, repo, watcher, :watchers,
["repos/#{user}/#{repo}/stargazers"],
{'repo' => repo, 'owner' => user},
'login', order = :desc)
end | ruby | {
"resource": ""
} |
q26561 | GHTorrent.Retriever.get_repo_events | test | def get_repo_events(owner, repo)
url = ghurl("repos/#{owner}/#{repo}/events")
r = paged_api_request(url)
r.each do |e|
unless get_event(e['id']).empty?
debug "Repository event #{owner}/#{repo} -> #{e['type']}-#{e['id']} already exists"
else
persister.store(:events,... | ruby | {
"resource": ""
} |
q26562 | GHTorrent.Retriever.retrieve_master_branch_diff | test | def retrieve_master_branch_diff(owner, repo, branch, parent_owner, parent_repo, parent_branch)
branch = retrieve_default_branch(owner, repo) if branch.nil?
parent_branch = retrieve_default_branch(parent_owner, parent_repo) if parent_branch.nil?
return nil if branch.nil? or parent_branch.nil?
... | ruby | {
"resource": ""
} |
q26563 | GHTorrent.Retriever.retrieve_default_branch | test | def retrieve_default_branch(owner, repo, refresh = false)
retrieved = retrieve_repo(owner, repo, refresh)
return nil if retrieved.nil?
master_branch = 'master'
if retrieved['default_branch'].nil?
# The currently stored repo entry has been created before the
# default_branch fiel... | ruby | {
"resource": ""
} |
q26564 | GHTorrent.Command.process_options | test | def process_options
command = self
@options = Trollop::options(command.args) do
command.prepare_options(self)
banner <<-END
Standard options:
END
opt :config, 'config.yaml file location', :short => 'c',
:default => 'config.yaml'
opt :verbose, 'verbose m... | ruby | {
"resource": ""
} |
q26565 | GHTorrent.Command.validate | test | def validate
if options[:config].nil?
unless (File.exist?("config.yaml"))
Trollop::die "No config file in default location (#{Dir.pwd}). You
need to specify the #{:config} parameter. Read the
documentation on how to create a config.yaml file."
... | ruby | {
"resource": ""
} |
q26566 | GHTorrent.Command.queue_client | test | def queue_client(queue, key = queue, ack = :after, block)
stopped = false
while not stopped
begin
conn = Bunny.new(:host => config(:amqp_host),
:port => config(:amqp_port),
:username => config(:amqp_username),
... | ruby | {
"resource": ""
} |
q26567 | GHTorrent.Utils.read_value | test | def read_value(from, key)
return from if key.nil? or key == ""
key.split(/\./).reduce({}) do |acc, x|
unless acc.nil?
if acc.empty?
# Initial run
acc = from[x]
else
if acc.has_key?(x)
acc = acc[x]
else
#... | ruby | {
"resource": ""
} |
q26568 | GHTorrent.Geolocator.location_filter | test | def location_filter(location)
return nil if location.nil?
location.\
strip.\
downcase.\
tr('#"<>[]', '').\
gsub(/^[0-9,\/().:]*/, '').\
gsub(/ +/, ' ').\
gsub(/,([a-z]*)/, '\1')
end | ruby | {
"resource": ""
} |
q26569 | Karafka.BaseResponder.validate_usage! | test | def validate_usage!
registered_topics = self.class.topics.map do |name, topic|
topic.to_h.merge!(
usage_count: messages_buffer[name]&.count || 0
)
end
used_topics = messages_buffer.map do |name, usage|
topic = self.class.topics[name] || Responders::Topic.new(name, re... | ruby | {
"resource": ""
} |
q26570 | Karafka.BaseResponder.validate_options! | test | def validate_options!
return true unless self.class.options_schema
messages_buffer.each_value do |messages_set|
messages_set.each do |message_data|
result = self.class.options_schema.call(message_data.last)
next if result.success?
raise Karafka::Errors::InvalidRespond... | ruby | {
"resource": ""
} |
q26571 | Karafka.BaseResponder.deliver! | test | def deliver!
messages_buffer.each_value do |data_elements|
data_elements.each do |data, options|
# We map this topic name, so it will match namespaced/etc topic in Kafka
# @note By default will not change topic (if default mapper used)
mapped_topic = Karafka::App.config.topic... | ruby | {
"resource": ""
} |
q26572 | Karafka.Process.notice_signal | test | def notice_signal(signal)
Thread.new do
Karafka.monitor.instrument('process.notice_signal', caller: self, signal: signal)
end
end | ruby | {
"resource": ""
} |
q26573 | TensorStream.EmbeddingLookup.embedding_lookup | test | def embedding_lookup(params, ids, partition_strategy: "mod", name: nil, validate_indices: true, max_norm: nil)
_embedding_lookup_and_transform(params, ids, partition_strategy: partition_strategy, name: name, max_norm: max_norm, transform_fn: nil)
end | ruby | {
"resource": ""
} |
q26574 | TensorStream.EmbeddingLookup._embedding_lookup_and_transform | test | def _embedding_lookup_and_transform(params, ids, partition_strategy: "mod", name: nil, max_norm: nil, transform_fn: nil)
raise TensorStream::ValueError, "Need at least one param" if params.nil?
params = [params] unless params.is_a?(Array)
TensorStream.name_scope(name, "embedding_lookup", values: par... | ruby | {
"resource": ""
} |
q26575 | TensorStream.Protobuf.load | test | def load(pbfile)
f = File.new(pbfile, "r")
lines = []
while !f.eof? && (str = f.readline.strip)
lines << str
end
evaluate_lines(lines)
end | ruby | {
"resource": ""
} |
q26576 | TensorStream.Ops.assert_equal | test | def assert_equal(x, y, data: nil, summarize: nil, message: nil, name: nil)
_op(:assert_equal, x, y, data: data, summarize: summarize, message: message, name: name)
end | ruby | {
"resource": ""
} |
q26577 | TensorStream.Ops.gradients | test | def gradients(tensor_ys, wrt_xs, name: "gradients", stop_gradients: nil)
tensor_ys = tensor_ys.op
gs = wrt_xs.map(&:op).collect { |x|
stops = stop_gradients ? stop_gradients.map(&:name).join("_") : ""
gradient_program_name = "grad_#{tensor_ys.name}_#{x.name}_#{stops}".to_sym
tensor_g... | ruby | {
"resource": ""
} |
q26578 | TensorStream.Ops.random_normal | test | def random_normal(shape, dtype: :float32, mean: 0.0, stddev: 1.0, seed: nil, name: nil)
options = {dtype: dtype, mean: mean, stddev: stddev, seed: seed, name: name}
_op(:random_standard_normal, shape, options)
end | ruby | {
"resource": ""
} |
q26579 | TensorStream.Ops.eye | test | def eye(num_rows, num_columns: nil, dtype: :float32, name: nil)
_op(:eye, num_rows, num_columns || num_rows, data_type: dtype, name: name)
end | ruby | {
"resource": ""
} |
q26580 | TensorStream.Ops.glorot_uniform_initializer | test | def glorot_uniform_initializer(seed: nil, dtype: nil)
TensorStream::Initializer.new(-> { _op(:glorot_uniform, seed: seed, data_type: dtype) })
end | ruby | {
"resource": ""
} |
q26581 | TensorStream.Ops.random_uniform_initializer | test | def random_uniform_initializer(minval: 0, maxval: 1, seed: nil, dtype: nil)
TensorStream::Initializer.new(-> { _op(:random_uniform, minval: 0, maxval: 1, seed: seed, data_type: dtype) })
end | ruby | {
"resource": ""
} |
q26582 | TensorStream.Ops.slice | test | def slice(input, start, size, name: nil)
_op(:slice, input, start, size: size, name: name)
end | ruby | {
"resource": ""
} |
q26583 | TensorStream.Ops.ones | test | def ones(shape, dtype: :float32, name: nil)
_op(:ones, shape, data_type: dtype, name: name)
end | ruby | {
"resource": ""
} |
q26584 | TensorStream.Ops.logical_and | test | def logical_and(input_a, input_b, name: nil)
check_data_types(input_a, input_b)
_op(:logical_and, input_a, input_b, name: name)
end | ruby | {
"resource": ""
} |
q26585 | TensorStream.Ops.reduce_mean | test | def reduce_mean(input_tensor, axis = nil, keepdims: false, name: nil)
reduce(:mean, input_tensor, axis, keepdims: keepdims, name: name)
end | ruby | {
"resource": ""
} |
q26586 | TensorStream.Ops.concat | test | def concat(values, axis, name: "concat")
if values.is_a?(Array)
_op(:concat, axis, *values, name: name)
else
_op(:concat, axis, values, name: name)
end
end | ruby | {
"resource": ""
} |
q26587 | TensorStream.Ops.dynamic_partition | test | def dynamic_partition(data, partitions, num_partitions, name: nil)
result = _op(:dynamic_partition, data, partitions, num_partitions: num_partitions, name: nil)
num_partitions.times.map do |index|
result[index]
end
end | ruby | {
"resource": ""
} |
q26588 | TensorStream.Ops.where | test | def where(condition, true_t = nil, false_t = nil, name: nil)
_op(:where, condition, true_t, false_t, name: name)
end | ruby | {
"resource": ""
} |
q26589 | TensorStream.Ops.asin | test | def asin(input, name: nil)
check_allowed_types(input, FLOATING_POINT_TYPES)
_op(:asin, input, name: name)
end | ruby | {
"resource": ""
} |
q26590 | TensorStream.Ops.acos | test | def acos(input, name: nil)
check_allowed_types(input, FLOATING_POINT_TYPES)
_op(:acos, input, name: name)
end | ruby | {
"resource": ""
} |
q26591 | TensorStream.Ops.atan | test | def atan(input, name: nil)
check_allowed_types(input, FLOATING_POINT_TYPES)
_op(:atan, input, name: name)
end | ruby | {
"resource": ""
} |
q26592 | TensorStream.Ops.cast | test | def cast(input, dtype, name: nil)
input = convert_to_tensor(input)
return input if input.data_type == dtype
_op(:cast, input, data_type: dtype, name: name)
end | ruby | {
"resource": ""
} |
q26593 | TensorStream.Ops.print | test | def print(input, data, message: nil, name: nil)
_op(:print, input, data, message: message, name: name)
end | ruby | {
"resource": ""
} |
q26594 | TensorStream.Ops.sec | test | def sec(input, name: nil)
check_allowed_types(input, FLOATING_POINT_TYPES)
_op(:sec, input, name: name)
end | ruby | {
"resource": ""
} |
q26595 | TensorStream.Ops.sqrt | test | def sqrt(input, name: nil)
check_allowed_types(input, FLOATING_POINT_TYPES)
_op(:sqrt, input, name: name)
end | ruby | {
"resource": ""
} |
q26596 | TensorStream.Ops.log | test | def log(input, name: nil)
check_allowed_types(input, FLOATING_POINT_TYPES)
_op(:log, input, name: name)
end | ruby | {
"resource": ""
} |
q26597 | TensorStream.Ops.exp | test | def exp(input, name: nil)
check_allowed_types(input, FLOATING_POINT_TYPES)
_op(:exp, input, name: name)
end | ruby | {
"resource": ""
} |
q26598 | TensorStream.Ops.pad | test | def pad(tensor, paddings, mode: "CONSTANT", name: nil)
_op(:pad, tensor, paddings, mode: mode, name: name)
end | ruby | {
"resource": ""
} |
q26599 | TensorStream.Ops.gather | test | def gather(params, indices, validate_indices: nil,
name: nil,
axis: 0)
_op(:gather, params, indices, validate_indices: validate_indices, name: name, axis: axis)
end | ruby | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.