query stringlengths 7 9.5k | document stringlengths 10 1.07M | negatives sequencelengths 19 19 | metadata dict |
|---|---|---|---|
GET /property_between_floor_slaps GET /property_between_floor_slaps.json | def index
@property_between_floor_slaps = PropertyBetweenFloorSlap.all
end | [
"def within_bounds\n min_latitude = Float(params[:sw_latitude])\n max_latitude = Float(params[:ne_latitude])\n min_longitude = Float(params[:sw_longitude])\n max_longitude = Float(params[:ne_longitude])\n limit = 1000 || params[:limit]\n offset = 0 || params[:offset]\n approved = true || params... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /property_between_floor_slaps POST /property_between_floor_slaps.json | def create
@property_between_floor_slap = PropertyBetweenFloorSlap.new(property_between_floor_slap_params)
respond_to do |format|
if @property_between_floor_slap.save
format.html { redirect_to @property_between_floor_slap, notice: 'Property between floor slap was successfully created.' }
format.json { render :show, status: :created, location: @property_between_floor_slap }
else
format.html { render :new }
format.json { render json: @property_between_floor_slap.errors, status: :unprocessable_entity }
end
end
end | [
"def index\n @property_between_floor_slaps = PropertyBetweenFloorSlap.all\n end",
"def create\n @shooting_range = ShootingRange.new(params[:shooting_range])\n\n respond_to do |format|\n if @shooting_range.save\n format.html { redirect_to(@shooting_range, :notice => 'Shooting range was succes... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /property_between_floor_slaps/1 PATCH/PUT /property_between_floor_slaps/1.json | def update
respond_to do |format|
if @property_between_floor_slap.update(property_between_floor_slap_params)
format.html { redirect_to @property_between_floor_slap , notice: 'Property between floor slap was successfully updated.' }
format.json { render :show, status: :ok, location: @property_between_floor_slap }
else
format.html { render :edit }
format.json { render json: @property_between_floor_slap.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n respond_to do |format|\n if @property_land_shape.update(property_land_shape_params)\n format.html { redirect_to @property_land_shape, notice: 'Property land shape was successfully updated.' }\n format.json { render :show, status: :ok, location: @property_land_shape }\n else\... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /property_between_floor_slaps/1 DELETE /property_between_floor_slaps/1.json | def destroy
@property_between_floor_slap.destroy
respond_to do |format|
format.html { redirect_to property_between_floor_slaps_url, notice: 'Property between floor slap was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @property_road.destroy\n respond_to do |format|\n format.html { redirect_to property_roads_url, notice: 'Property road was successfully destroyed.' }\n format.json { head :no_content }\n end\n end",
"def delete_floor_plan(args = {}) \n delete(\"/files.json/floorplan/images\", ar... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Unregisters the webhook with Jive | def unregister_webhook
require "open-uri"
require "net/http"
require "openssl"
return if self.add_on.nil? # Can't do it without a token!
return if self.oauth_token.nil? # Can't do it without a token!
uri = URI.parse("#{self.add_on.jive_url}/api/core/v3/webhooks/#{self.webhook_id}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Delete.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer #{self.oauth_token.access_token}"
response = http.request(request)
# Need 2XX status code
if !response.code.to_i.between?(200, 299)
errors[:base] << "#{request.inspect} => #{response.body}"
return false
end
true
end | [
"def remove_webhook\n request(URL::WEBHOOK, url: '')\n end",
"def delete_webhook\n send_request('deleteWebhook', {})\n end",
"def unsubscribe_request_hook(name)\n EasyPost::Hooks.unsubscribe(:request, name)\n end",
"def delete_webhook(target_url)\n Uploadcare::Webhook.delete(t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Registers the webhook with Jive | def register_webhook
require "open-uri"
require "net/http"
require "openssl"
uri = URI.parse("#{self.add_on.jive_url}/api/core/v3/webhooks")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
#http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(uri.request_uri)
request["Content-Type"] = "application/json"
request["Authorization"] = "Bearer #{self.oauth_token.access_token}"
body = {
"callback" => self.callback,
"object" => self.object,
}
body["events"] = self.events if !self.events.to_s.empty?
request.body = body.to_json
response = http.request(request)
# Need 2XX status code
if !response.code.to_i.between?(200, 299)
errors[:base] << "#{request.inspect} => #{response.body}"
return false
end
json_body = JSON.parse(response.body)
self.webhook_id = json_body["id"]
true
end | [
"def create_webhook(webhook_id, request)\n start.uri('/api/webhook')\n .url_segment(webhook_id)\n .body_handler(FusionAuth::JSONBodyHandler.new(request))\n .post()\n .go()\n end",
"def create_webhook(webhook_id, request)\n start.uri('/api/webhook')\n .... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Refresh one feed source and return the updated feed items | def refresh
FeedSource.find(params[:feed_source_id]).refresh
feed_sources = params[:feed_sources]
@feed_source_titles = {}
FeedSource.find(feed_sources).each { |source| @feed_source_titles[source.id] = source.title}
@feed_items = FeedItem.where("feed_source_id IN (?)", feed_sources).order(pub_date: :desc).limit(20).offset(0)
@feed_items = @feed_items.sort_by{ |item| item.pub_date.to_i }.reverse
render :index
end | [
"def refresh_feed(feed)\n FeedRefreshManager.refresh feed, self\n end",
"def update!\n data = fx_feed.get\n data = remove_cached_records(data)\n data.each(&:save)\n end",
"def refresh!\n fetch_data\n end",
"def refresh\n raise \"Source classes must implement their own ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Store page title options that are used on I18n interpolation. | def page_title_options
@page_title_options ||= {}
end | [
"def page_title(options = {})\n return \"\" if @page.title.blank?\n\n options = {\n prefix: \"\",\n suffix: \"\",\n separator: \"\"\n }.update(options)\n title_parts = [options[:prefix]]\n title_parts << if response.status == 200\n @page.title\n else\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Override in the subclass to provide a place to do initialization of game logic, load files, set up state, etc | def game_setup
end | [
"def initialize\n\t\tinitialize_game\n\tend",
"def initialize_game\n setup_boards\n end",
"def process_init\n end",
"def post_init\n end",
"def initialize(parent_wnd)\r\n super(parent_wnd)\r\n \r\n @core_game = nil\r\n @splash_name = File.join(@resource_path, \"icons/mariazza_tit... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Called on an instance of the subclass, this will run the game_setup method and then begin the show loop on the delegate | def game_start
game_setup
@console_delegate.show
end | [
"def game_setup\n end",
"def setup_game\n\t\t@game_board = Board.new\n\t\t@game_engine = GameEngine.new(@game_board)\n\t\tupdate_ui\n\tend",
"def setup_new_game\n Game.new.play\n end",
"def run\r\n @log.debug \"Run the tester...\"\r\n @dlg_box = CupSingleGameWin.new(@options)\r\n @dlg_bo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Gets the chat property value. The chat between the user and Teams app. | def chat
return @chat
end | [
"def chat_info\n return @chat_info\n end",
"def chat_info\n return @chat_info\n end",
"def chat\n @_chat || payload && payload['chat']\n end",
"def chat=(value)\n @chat = value\n end",
"def chat\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Sets the chat property value. The chat between the user and Teams app. | def chat=(value)
@chat = value
end | [
"def set_chat(chat)\n @msg.chat = chat if @msg\n end",
"def chat_info=(value)\n @chat_info = value\n end",
"def chat_info=(value)\n @chat_info = value\n end",
"def chat_id=(value)\n @chat_id = value\n end",
... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Instantiates a new userScopeTeamsAppInstallation and sets the default values. | def initialize()
super
@odata_type = "#microsoft.graph.userScopeTeamsAppInstallation"
end | [
"def initialize()\n super\n @odata_type = \"#microsoft.graph.teamworkApplicationIdentity\"\n end",
"def installed_apps()\n return MicrosoftGraph::Me::JoinedTeams::Item::InstalledApps::InstalledAppsRequestBuilder.new(@path_parameters, @request_adapter... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GPS version Returns an array of projects that are similar if project exists | def project_exists
if self.check_project_exists == true
return (Project.select{ |proj| proj.project_type == self.project_type } && Project.select{ |proj| proj.street1.to_f.between?((self.street1.to_f - 0.02), (self.street1.to_f + 0.02))} && Project.select{ |proj| proj.street2.to_f.between?((self.street2.to_f - 0.02), (self.street2.to_f + 0.02 ))})
else
return []
end
end | [
"def nearby_projects(projects,latitude,longitude)\n @projects_seventy_five = @matched_projects\n # to remove duplicates from array\n @projects_fifty = @projects_seventy_five - @projects_fifty\n @seventy_five = false\n @hundred = false\n matched_projects = projects.near([latitude, longitude], 50, u... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GPS version check for projects that have similar streets reversing street order as necessary. | def check_project_exists
# if latitude is within +/- 2 ten-thounsandths of another project's latitude it is the same
(Project.select{ |proj| proj.project_type == self.project_type }.count > 0 && Project.select{ |proj| proj.street1.to_f.between?((self.street1.to_f - 0.002), (self.street1.to_f + 0.002))}.count > 0 && Project.select{ |proj| proj.street2.to_f.between?((self.street2.to_f - 0.02), (self.street2.to_f + 0.02))}.count > 0)
end | [
"def street_similar(form_street_address,va_street_address)\n return false if va_street_address.nil?\n return va_street_address.jarowinkler_similar(form_street_address) > 0.8 ? true : false\n end",
"def nearby_projects(projects,latitude,longitude)\n @projects_seventy_five = @matched_projects\n ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Details: Finish the solution so that it sorts the passed in array of numbers. If the function passes in an empty array or null/nil value then it should return an empty array. For example: solution([1, 2, 10, 50, 5]) should return [1,2,5,10,50] solution(nil) should return [] | def solution(nums)
nums.to_a.sort
end | [
"def solution(nums)\n nums.nil? ? [] : nums.sort\nend",
"def sort_array(nums)\n nums.nil? ? [] : nums.sort\nend",
"def introspective_sort(array)\n return array if array.empty?\n\n depth_limit = (2 * Math.log10(array.size) / Math.log10(2)).floor\n quick_sort(array, depth_limit)\nend",
"def sorting(numbers... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /regionextras GET /regionextras.json | def index
@regionextras = Regionextra.all
end | [
"def region\n @regions = @company.companyregions\n respond_with @regions\n end",
"def regions\n client.get_stats('/stats/regions')\n end",
"def regions\n @carrierRegions = []\n if session[:carrier]\n soap_client = MyFreightWorldCarrier.new\n @carrierRegions = soap_client.getRegions(se... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /regionextras POST /regionextras.json | def create
@regionextra = Regionextra.new(regionextra_params)
respond_to do |format|
if @regionextra.save
format.html { redirect_to @regionextra, notice: 'Regionextra was successfully created.' }
format.json { render :show, status: :created, location: @regionextra }
else
format.html { render :new }
format.json { render json: @regionextra.errors, status: :unprocessable_entity }
end
end
end | [
"def create\n @region = Region.new(region_params)\n\n if @region.save\n render json: @region, status: :created, location: @region\n else\n render json: @region.errors, status: :unprocessable_entity\n end\n end",
"def createregion\n region_name = params[\"regionName\"]\n region_active ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
PATCH/PUT /regionextras/1 PATCH/PUT /regionextras/1.json | def update
respond_to do |format|
if @regionextra.update(regionextra_params)
format.html { redirect_to @regionextra, notice: 'Regionextra was successfully updated.' }
format.json { render :show, status: :ok, location: @regionextra }
else
format.html { render :edit }
format.json { render json: @regionextra.errors, status: :unprocessable_entity }
end
end
end | [
"def update\n @region = Region.find(params[:id])\n\n if @region.update(region_params)\n head :no_content\n else\n render json: @region.errors, status: :unprocessable_entity\n end\n end",
"def update\n do_load_resource\n get_project_if_exists\n do_authorize_instance\n\n @original... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
DELETE /regionextras/1 DELETE /regionextras/1.json | def destroy
@regionextra.destroy
respond_to do |format|
format.html { redirect_to regionextras_url, notice: 'Regionextra was successfully destroyed.' }
format.json { head :no_content }
end
end | [
"def destroy\n @region.destroy\n\n respond_to do |format|\n format.html { redirect_to regions_url }\n format.json { head :no_content }\n end\n end",
"def destroy\n @region.destroy\n\n head :no_content\n end",
"def destroy\n @region.destroy\n respond_to do |format|\n format.... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
=begin need function that takes and argument that argument will be an array reference value to check against if the next number is bigger than reference value it becomes the reference value at the end of iterating over each item the reference value the largest number =end | def max_value(our_array)
reference = -100000
our_array.each do |number|
if number > reference
reference = number
end
end
reference
end | [
"def max_number(our_array)\n\treference = -1000000\n\tour_array.each do |number|\n\t\tif number > reference\n\t\t\treference = number\n\t\tend\n\tend\n\treference\nend",
"def largest(array)\n index = 0 #1\n greatest_num = array[index] #5 \n while index < arr... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Overwrites slug_exists? from Slug. We allow duplicate slugs on different published_at dates. | def slug_exists?
Article.on(published_at).where(slug: slug).exists?
end | [
"def slug_unique?(test_slug, existing = existing_slugs)\n !existing.include?(test_slug)\n end",
"def slug_unique?(slug)\n self.class.find_by(slug: slug).nil?\n end",
"def slug_is_unique\n true\n end",
"def slug_unchanged?(slug)\n self.slug == slug\n end",
"def slugged?\n !slug.bla... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
START Feed Action Tests | def test_get_feed
get :feed
assert_response :success
end | [
"def test_mp3_feed_works\n get \"/podcast_feed/all/mp3/rss.xml\"\n assert last_response.ok?\n end",
"def test\n @entries = @feed.test\n rescue Exception => e\n flash[:error] = e.message\n redirect_to(admin_feeds_url)\n end",
"def test_feed_user\n user = create(:user)\n changesets = creat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Class method version of Gorilla::Unitnormalize, to handle, e.g., Enumerable, Numeric, and Range objects. | def normalize input, &block
case input
when Range
normalize(input.min, &block)..normalize(input.max, &block)
when Enumerable
input.map { |unit| normalize unit, &block }
when Numeric
normalize Unit.new(input), &block
else # Unit, etc.
input.normalize(&block)
end
end | [
"def convert_units(obj, un)\n begin\n obj.convert_units(un) # for GPhys etc\n rescue\n obj.convert2(un) # for UNumeric etc\n end\n end",
"def normalize_units(u)\n if u.blank?\n u = nil\n else\n u = u.to_s\n u = UNIT_SYN[... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Returns whether a unit was defined as metric. ==== Example class Coolness true end Coolness.new(1, :megaFonzie).metric? => true | def metric?
unit and self.class.rules[unit][:metric] || false
end | [
"def metric?\n @metric\n end",
"def metric_ton? = unit == 'metric-ton'",
"def is_metric?(unit)\n return (unit == \"mm\" || unit == \"cm\" || unit == \"m\" || unit == \"km\")\n end",
"def metric?\n false\n end",
"def cup_metric? = unit == 'cup-metric'",
"def square_meter? = unit == 'squ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Get exception status detail | def status_details(exception)
StatusDetails.new(message: exception&.message, trace: exception&.backtrace&.join("\n"))
end | [
"def status_details\n return nil unless cause.respond_to? :status_details\n cause.status_details\n end",
"def status\n return 404 if NOT_FOUND_ERRORS.include? @exception.class.to_s\n @exception.respond_to?(:http_status) ? @exception.http_status : 500\n end",
"def get_http_status ... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Retrieve all CPEs and their associated variants. The 'live' field in the output indicates whether any advisory has been shipped for that CPE and variant. This API does not require authentication. :apiurl: /api/v1/security/cpes :apimethod: GET :apiresponseexample: file:publican_docs/Developer_Guide/api_examples/cpes.json | def cpes
@variants = Variant.all.group_by{|variant| variant.cpe || ''}.sort_by{|cpe,v| cpe}
end | [
"def index\n if params[:cep]\n @api_ceps = Api::Cep.find_by(cep: params[:cep])\n if @api_ceps\n render json: {ceps: @api_ceps}, status: 202\n else\n render json: {error: 'CEP not found'}, status: 404\n end\n else\n @api_ceps = Api::Cep.all\n render json: {ceps: @api... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a SUBSCRIBE frame. Sets `ack` header to 'auto' unless it is already set to 'client' or 'clientindividual'. | def subscribe_frame d, h
h[:ack] = 'auto' unless ['client', 'client-individual'].include?(h[:ack])
create_frame 'SUBSCRIBE', [{:id => OnStomp.next_serial}, h, {:destination => d}]
end | [
"def subscribe_frame d, h\n h[:ack] = 'auto' unless h[:ack] == 'client'\n create_frame 'SUBSCRIBE', [{:id => OnStomp.next_serial}, h, {:destination => d}]\n end",
"def test_client_ack_with_symbol_10\n if @conn.protocol != Stomp::SPL_10\n assert true\n return\n end\n queue = make_destinat... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an ACK frame | def ack_frame *args
create_ack_or_nack 'ACK', args
end | [
"def sendAck\n $LOG.debug \"Sending ACK\"\n send_msg ack Messages::EndType::ACK\n end",
"def ack_frame *args\n headers = args.last.is_a?(Hash) ? args.pop : {}\n m_id = args.shift\n m_id = m_id[:'message-id'] if m_id.is_a?(OnStomp::Components::Frame)\n create_frame('ACK', [{:'message-id' => m_id... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates an NACK frame | def nack_frame *args
create_ack_or_nack 'NACK', args
end | [
"def ack_frame *args\n create_ack_or_nack 'ACK', args\n end",
"def makeframe(packetdata)\n\t\tif packetdata.size > 255\n\t\t\tprint_error(\"#{rhost}:#{rport} - MODBUS - Packet too large: #{packetdata.inspect}\")\n\t\t\treturn\n\t\tend\n\t\tpayload = \"\"\n\t\tpayload += [@modbuscounter].pack(\"n\")\n\t\tpaylo... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
Creates a heartbeat frame (serialized as a single "\n" character) | def heartbeat_frame
OnStomp::Components::Frame.new
end | [
"def sendHeartbeat()\n send!(0, :HB, -1, -1, -1, -1)\n end",
"def send_heartbeat(sequence)\n send_packet(Opcodes::HEARTBEAT, sequence)\n end",
"def make_event_frame( payload )\n\t\tframe = Mongrel2::WebSocket::Frame.new( '', 0, '', {}, payload )\n\t\tframe.opcode = :text\n\n\t\treturn frame.to_s\n\t... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
tyear, tmonth, tweek assigned where setting spent_on attributes these attributes make time aggregations easier | def spent_on=(date)
super
self.tyear = spent_on ? spent_on.year : nil
self.tmonth = spent_on ? spent_on.month : nil
self.tweek = spent_on ? spent_on.cweek : nil
end | [
"def spent_on=(date)\n super\n self.tyear = spent_on ? spent_on.year : nil\n self.tmonth = spent_on ? spent_on.month : nil\n self.tweek = spent_on ? Date.civil(spent_on.year, spent_on.month, spent_on.day).cweek : nil\n self.spent_from = date\n self.spent_to = self.spent_from.advance(:hours=>hours)... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
GET /stay_times GET /stay_times.json | def index
@stay_times = StayTime.all
end | [
"def index\n get_todays_data\n\n respond_to do |format|\n format.html { }\n format.json { json_response(@set_times) }\n end\n end",
"def index\n @time_entries = TimeEntry.all\n render :json => @time_entries, status: :ok\n end",
"def index\n \n @task_time... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
POST /stay_times POST /stay_times.json | def create
@stay_time = StayTime.new(stay_time_params)
respond_to do |format|
if @stay_time.save
format.html { redirect_to @stay_time, notice: 'Stay time was successfully created.' }
format.json { render :show, status: :created, location: @stay_time }
else
format.html { render :new }
format.json { render json: @stay_time.errors, status: :unprocessable_entity }
end
end
end | [
"def index\n @stay_times = StayTime.all\n end",
"def create\n @timing = Timing.new(params[:timing].slice(:start, :stop, :days, :parent_class, :parent_id, :active))\n if @timing.save\n render json: @timing\n else\n render json: { error: 'error: could not save timing' }\n end\n end",
"d... | {
"objective": {
"paired": [],
"self": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 25