ToCode

llm.read_timeout = 600

json_schema = {
  type: "object",
  properties: {
    name: {
      type: "string",
      description: "Persons name"
    },
    age: {
      type: "number",
      description: "Persons age"
    },
    interests: {
      type: "array",
      items: {
        type: "object",
        properties: {
          interest: {
            type: "string",
            description: "A topic of interest"
          },
          levelOfInterest: {
            type: "number",
            description: "A value between 0 and 100 of how interested the person is in this interest"
          }
        },
        required: ["interest", "levelOfInterest"],
        additionalProperties: false
      },
      minItems: 1,
      maxItems: 3,
      description: "A list of the person's interests"
    }
  },
  required: ["name", "age", "interests"],
  additionalProperties: false
}
parser = Langchain::OutputParsers::StructuredOutputParser.from_json_schema(json_schema)
prompt = Langchain::Prompt::PromptTemplate.new(template: "Generate details of a fictional character.\n{format_instructions}\nCharacter description: {description}", input_variables: ["description", "format_instructions"])
prompt_text = prompt.format(description: "Korean chemistry student", format_instructions: parser.get_format_instructions)

llm = Langchain::LLM::OpenAI.new(api_key: ENV["OPENAI_API_KEY"])
llm_response = llm.chat(messages: [{role: "user", content: prompt_text}]).completion
parser.parse(llm_response)

    def http_post(url, params)
      http = Net::HTTP.new(url.hostname, url.port)
      http.use_ssl = url.scheme == "https"
      http.set_debug_output(Langchain.logger) if Langchain.logger.debug?

      request = Net::HTTP::Post.new(url)
      request.content_type = "application/json"
      request.body = params.to_json

      response = http.request(request)

      JSON.parse(response.body)
    end

require 'langchain/llm/google_gemini'

* This module adds a dedicated \read_timeout\ attribute to the class. *
module GoogleGeminiTimeoutAttribute
  # This one line creates two methods for us:
  # 1. \read_timeout\ (the getter, to read the value)
  # 2. \read_timeout=\ (the setter, to assign the value)
  # It manages the underlying instance variable \@read_timeout\.
  attr_accessor :read_timeout

  # We still patch http_post to use the value from our new attribute.
  def http_post(url, params)
    http = Net::HTTP.new(url.hostname, url.port)
    http.use_ssl = url.scheme == "https"
    http.set_debug_output(Langchain.logger) if Langchain.logger.debug?
    http.read_timeout = @read_timeout if @read_timeout

    request = Net::HTTP::Post.new(url)
    request.content_type = "application/json"
    request.body = params.to_json

    response = http.request(request)

    JSON.parse(response.body)
  end
end

Langchain::LLM::GoogleGemini.prepend(GoogleGeminiTimeoutAttribute)

http.read_timeout = @read_timeout if @read_timeout

llm = Langchain::LLM::GoogleGemini.new(
  api_key: Rails.application.credentials.google_api_key,
  default_options: { chat_model: 'gemini-2.5-pro-preview-05-06' },
)

import { MovieGrid } from "../components/movie-grid.tsx";
import { MovieTile } from "../components/movie-tile.tsx";

export const shouldRevalidate = () => false;

export async function ServerComponent() {
  let featuredMovieIds = [32932, 23643, 29915, 30895, 31472, 33411];

  return (
    <>
      <title>RR RSC Movies</title>
      <MovieGrid>
        {featuredMovieIds.map((id: number) => (
          <MovieTile key={id} id={id} />
        ))}
      </MovieGrid>
    </>
  );
}

"use client";
import { useFormStatus } from "react-dom";

export function AddToFavoritesButton({ isLiked }: { isLiked: boolean }) {
  let { pending } = useFormStatus();

  return (
    <button
      type="submit"
      onClick={event => {
        if (pending) event.preventDefault();
      }}
      className="font-instrumentSans font-semibold rounded-xl w-full text-xl border-[2px] py-2 px-5 group"
    >
      <span className="group-hover:scale-105 group-active:scale-100 inline-block transition-transform duration-100">
        {pending
          ? isLiked
            ? "Removing..."
            : "Adding..."
          : isLiked
            ? "Remove from favorites"
            : "Add to favorites"}
      </span>
    </button>
  );
}

import { memo } from 'react';

const NewMessage = memo(() => {
  return <p>demo</p>;
})

NewMessage.displayName = "foo";

export default NewMessage;

'use client';

import { memo } from 'react';

const NewMessage = () => {
  return <p>demo</p>;
}
NewMessage.displayName = 'foo';

export default memo(NewMessage);

class Category < ApplicationRecord
  has_many :products
end

class Product < ApplicationRecord
  belongs_to :category

  # Default scope to always order products by weight
  default_scope { order(:weight) }
end

category = Category.first
category.products

category.products.order(weight: :desc)

category.products.unscope(:order).order(weight: :desc)