Google Shopping Macbook M3 Script

I need to create a script from this. Lets see it work first and then modify it:: https://serpapi.com/search.json?engine=google_shopping&q=Macbook+M3 + require ‘google_search_results’

params = {
engine: “google_shopping”,
q: “Macbook M3”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

To create a script using the `google_search_results` gem to fetch Google Shopping results for “Macbook M3”, you’ll need to ensure you have the gem installed and then set up the script as shown below. Here is a complete and functional Ruby script to perform this task:

1. **Install the Gem**: Ensure you have the `google_search_results` gem installed. You can install it using the following command:
“`sh
gem install google_search_results
“`

2. **Script**: Use the following Ruby script to perform the search and fetch the shopping results:

“`ruby
require ‘google_search_results’

# Define the search parameters
params = {
engine: “google_shopping”,
q: “Macbook M3”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Output the results
puts “Shopping Results for Macbook M3:”
shopping_results.each do |result|
puts “Title: #{result[:title]}”
puts “Price: #{result[:price]}”
puts “Link: #{result[:link]}”
puts “———————–”
end
“`

### Explanation:
1. **Require the Gem**: The script begins by requiring the `google_search_results` gem.
2. **Define Parameters**: A hash named `params` is defined with the search parameters including the engine type (`google_shopping`), the query (`Macbook M3`), and the API key.
3. **Perform the Search**: An instance of `GoogleSearch` is created with the parameters, and the `get_hash` method is called to fetch the search results.
4. **Output the Results**: The script iterates through the `shopping_results` array, printing out the title, price, and link of each shopping result.

### Running the Script:
Save the script to a file (e.g., `google_shopping_search.rb`) and run it using the Ruby interpreter:
“`sh
ruby google_shopping_search.rb
“`

This script will fetch and display the shopping results for “Macbook M3” using the SerpApi service. Let me know if you need any modifications or additional features!
wai) D:EveBusinesspricing>gem install google_search_results
‘gem’ is not recognized as an internal or external command,
operable program or batch file.
It appears that the `gem` command is not recognized, which suggests that Ruby might not be installed on your system or it is not properly configured in your system’s PATH. Here’s how you can address this:

### Step 1: Install Ruby

1. **Windows**:
– Download and install RubyInstaller from [RubyInstaller for Windows](https://rubyinstaller.org/).
– During the installation process, make sure to check the option to add Ruby to your PATH.

2. **macOS**:
– Ruby is usually pre-installed on macOS. You can verify by running `ruby -v` in the terminal.

3. **Linux**:
– Use your package manager. For example, on Ubuntu:
“`sh
sudo apt-get install ruby-full
“`

### Step 2: Verify the Installation

After installing Ruby, open a new command prompt or terminal and check if Ruby is correctly installed by running:
“`sh
ruby -v
gem -v
“`
You should see the version numbers of Ruby and Rubygems.

### Step 3: Install the `google_search_results` Gem

With Ruby and Rubygems installed, you can now install the `google_search_results` gem:
“`sh
gem install google_search_results
“`

### Step 4: Create and Run the Script

Save the following script as `google_shopping_search.rb`:

“`ruby
require ‘google_search_results’

# Define the search parameters
params = {
engine: “google_shopping”,
q: “Macbook M3”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

Run the script using:
“`sh
ruby google_shopping_search.rb
“`

### Troubleshooting

If you still encounter issues with the `gem` command:

1. **Check Environment Variables**:
Ensure the PATH environment variable includes the path to the Ruby `bin` directory.

2. **Restart Command Prompt/Terminal**:
After installation or changes to PATH, restart your command prompt or terminal.

3. **Check Ruby Installation**:
Ensure Ruby and Rubygems are properly installed by running `ruby -v` and `gem -v`.

Let me know if you encounter any further issues or need additional assistance!
Can this be converted to something I use on windows?
Yes, the script can be used on Windows. Here are detailed steps to ensure it works on your Windows system:

### Step 1: Install Ruby on Windows

1. **Download Ruby Installer**:
– Go to the [RubyInstaller for Windows](https://rubyinstaller.org/).
– Download the latest version of Ruby with DevKit.

2. **Install Ruby**:
– Run the installer.
– During installation, make sure to check the option to add Ruby to your PATH.

### Step 2: Verify Ruby Installation

After installing Ruby, open a new Command Prompt and check the installation:

“`sh
ruby -v
gem -v
“`

You should see version numbers for Ruby and Gem.

### Step 3: Install the `google_search_results` Gem

In the Command Prompt, install the `google_search_results` gem by running:

“`sh
gem install google_search_results
“`

### Step 4: Create and Run the Ruby Script

1. **Create the Script**:
– Open a text editor (e.g., Notepad).
– Copy and paste the following script:

“`ruby
require ‘google_search_results’

# Define the search parameters
params = {
engine: “google_shopping”,
q: “Macbook M3”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

2. **Save the Script**:
– Save the file with a `.rb` extension, for example, `google_shopping_search.rb`.

3. **Run the Script**:
– In the Command Prompt, navigate to the directory where you saved the script.
– Run the script using the Ruby interpreter:

“`sh
ruby google_shopping_search.rb
“`

### Example Command Sequence

Here is a step-by-step sequence you might follow in the Command Prompt:

1. Install Ruby (done via installer as explained).
2. Verify installation:
“`sh
ruby -v
gem -v
“`
3. Install the `google_search_results` gem:
“`sh
gem install google_search_results
“`
4. Create and save the script as `google_shopping_search.rb`.
5. Navigate to the script’s directory:
“`sh
cd pathtoyourscript
“`
6. Run the script:
“`sh
ruby google_shopping_search.rb
“`

By following these steps, you should be able to run the script on your Windows system successfully. If you encounter any issues, please provide details of the error messages for further assistance.
does ruby have a gui?

Ruby itself does not come with a built-in graphical user interface (GUI) framework, but there are several libraries and frameworks available that allow you to create GUI applications in Ruby. Some of the popular ones include:

### 1. **Shoes**
Shoes is a simple and easy-to-use toolkit for building GUI applications in Ruby. It’s designed to be easy for beginners.

– **Installation**:
“`sh
gem install shoes
“`
– **Example**:
“`ruby
Shoes.app do
button “Click me” do
alert “Hello, World!”
end
end
“`

### 2. **Tk**
Ruby/Tk is a binding to the Tk GUI toolkit. Tk is a cross-platform toolkit that comes with a variety of widgets.

– **Installation** (usually comes with Ruby, but you might need to install Tk separately):
“`sh
gem install tk
“`
– **Example**:
“`ruby
require ‘tk’

root = TkRoot.new { title “Hello, Tk!” }
TkLabel.new(root) do
text ‘Hello, World!’
pack { padx 15; pady 15; side ‘left’ }
end
Tk.mainloop
“`

### 3. **FXRuby**
FXRuby is a Ruby binding to the FOX toolkit, which is known for its speed and portability.

– **Installation**:
“`sh
gem install fxruby
“`
– **Example**:
“`ruby
require ‘fox16’

include Fox

application = FXApp.new
main_window = FXMainWindow.new(application, “Hello”, :width => 300, :height => 200)

FXButton.new(main_window, “Hello, World!”).connect(SEL_COMMAND) do
exit
end

application.create
main_window.show(PLACEMENT_SCREEN)
application.run
“`

### 4. **GTK3**
Ruby-GTK3 is a set of bindings for the GTK+ toolkit, a highly flexible and powerful toolkit.

– **Installation**:
“`sh
gem install gtk3
“`
– **Example**:
“`ruby
require ‘gtk3’

win = Gtk::Window.new
win.set_title(“Hello, GTK!”)
win.set_default_size(200, 100)
win.signal_connect(“destroy”) { Gtk.main_quit }

button = Gtk::Button.new(:label => “Hello, World!”)
button.signal_connect(“clicked”) { puts “Hello, World!” }
win.add(button)

win.show_all
Gtk.main
“`

### 5. **QtRuby**
QtRuby is a set of bindings for the Qt toolkit, which is known for its powerful and versatile GUI components.

– **Installation** (might require Qt libraries):
“`sh
gem install qtbindings
“`
– **Example**:
“`ruby
require ‘qt’

app = Qt::Application.new(ARGV)
hello = Qt::PushButton.new(‘Hello, World!’)
hello.resize(100, 30)
hello.show
app.exec
“`

### Using Shoes for a Simple GUI

Given its simplicity, let’s create a simple GUI application using Shoes:

1. **Install Shoes**:
“`sh
gem install shoes
“`

2. **Create a Simple Shoes Application**:
“`ruby
Shoes.app do
stack do
para “Enter your query:”
@query = edit_line
button “Search” do
alert @query.text
end
end
end
“`

3. **Run the Application**:
Save the script as `shoes_app.rb` and run it using:
“`sh
shoes shoes_app.rb
“`

By using one of these libraries, you can create GUI applications in Ruby on your Windows system. Let me know if you need further guidance or if you have any specific requirements!
I am used to dataframes to display this price lookup. I want to know more about it
If you are familiar with dataframes for displaying data, you’re likely accustomed to using tools like Pandas in Python. Ruby has its own equivalent libraries for handling and displaying data in a tabular format. One popular library for data manipulation and analysis in Ruby is `Daru` (Data Analysis in RUby).

### Using Daru for DataFrames in Ruby

**Daru** is a powerful library for data manipulation and analysis, similar to Pandas in Python. You can use it to display the results of your price lookup in a dataframe format.

### Step-by-Step Guide

1. **Install Daru**:
You need to install the `daru` gem. You can do this via the command line:

“`sh
gem install daru
“`

2. **Create and Run a Script**:
Here’s how you can modify your script to use Daru for displaying the price lookup results in a dataframe.

“`ruby
require ‘google_search_results’
require ‘daru’

# Define the search parameters
params = {
engine: “google_shopping”,
q: “Macbook M3”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Prepare data for the dataframe
titles = []
prices = []
links = []

shopping_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe
puts df.inspect
“`

### Explanation:
1. **Require Libraries**:
The script requires `google_search_results` for fetching data and `daru` for creating the dataframe.

2. **Define Search Parameters**:
Set up the parameters for the search query.

3. **Perform the Search**:
Use `GoogleSearch` to perform the search and retrieve shopping results.

4. **Prepare Data for DataFrame**:
Iterate through the `shopping_results` to extract titles, prices, and links into separate arrays.

5. **Create and Display DataFrame**:
Use `Daru::DataFrame` to create a dataframe from the arrays and print it.

### Running the Script

1. Save the script to a file, e.g., `google_shopping_with_daru.rb`.
2. Run the script using:
“`sh
ruby google_shopping_with_daru.rb
“`

### Output Example

The output will look something like this:

“`
#
Title Price Link
0 Macbook M3 Pro $1,299.99 https://example.com/…
1 Macbook M3 Air $999.99 https://example.com/…
2 Macbook M3 Max $1,999.99 https://example.com/…
“`

This will display your search results in a tabular format using Daru, similar to how you might use Pandas in Python.

### Additional Features

Daru supports various functionalities such as:
– Data manipulation (filtering, grouping, merging)
– Statistical analysis
– Data visualization (integrates with visualization libraries)

To learn more about Daru and its capabilities, you can check out the [official documentation](https://github.com/SciRuby/daru) and explore more advanced usage scenarios.
Here is a trick question: Lets say there are mulitple items sku that come back from the search – how to narrow the searchto onl the item I am looking for eg: PF-110-6053 show a lot of differnt products, but this is an automotive model number. How do I modifty the search paramters?
To narrow down the search results to a specific SKU or model number, you can modify the search parameters to include more specific terms. This approach helps filter out irrelevant results and targets the exact product you’re looking for. Here’s how you can achieve that using the `google_search_results` gem and Ruby:

### Step-by-Step Guide

1. **Modify Search Parameters**:
Adjust the query to be more specific by including the SKU or model number directly in the search string.

2. **Filter Results**:
After fetching the results, you can further filter them programmatically to ensure they match the desired SKU or model number.

### Example Script

Below is an updated script that demonstrates how to narrow down search results for a specific SKU, `PF-110-6053`, which is an automotive model number.

“`ruby
require ‘google_search_results’
require ‘daru’

# Define the search parameters with specific SKU
params = {
engine: “google_shopping”,
q: “PF-110-6053 automotive”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Filter results to match the exact SKU
filtered_results = shopping_results.select do |result|
result[:title].include?(“PF-110-6053”)
end

# Prepare data for the dataframe
titles = []
prices = []
links = []

filtered_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe
puts df.inspect
“`

### Explanation:
1. **Modify Search Parameters**:
The query parameter (`q`) is updated to include the SKU `PF-110-6053` and the term `automotive` to make the search more specific.

2. **Filter Results**:
After fetching the search results, the script filters them using Ruby’s `select` method to ensure only items that contain the SKU `PF-110-6053` in their title are included.

3. **Prepare Data for DataFrame**:
The script prepares the data by iterating through the filtered results and extracting titles, prices, and links.

4. **Create and Display DataFrame**:
The `Daru::DataFrame` is created from the filtered data and printed.

### Running the Script

1. Save the script to a file, e.g., `filtered_google_shopping_search.rb`.
2. Run the script using:
“`sh
ruby filtered_google_shopping_search.rb
“`

### Output Example

The output will look something like this if there are matching items:

“`
#
Title Price Link
0 PF-110-6053 Filter $29.99 https://example.com/…
“`

This script ensures that only the relevant product with the exact SKU `PF-110-6053` is included in the results, making your search more precise and useful. If you need further customization or additional filters, you can extend the script accordingly.
Can ou make the table a lot wider on my screen I have a 1080
To make the table display wider and utilize the full width of a 1080p screen, you can format the output for better readability. The `daru` gem itself provides basic table formatting, but you might want to use another library or customize the printing format for enhanced visuals.

One way to achieve this is by using the `terminal-table` gem to display the dataframe in a more structured and wide format in the terminal.

### Step-by-Step Guide

1. **Install the Necessary Gems**:
Ensure you have both `daru` and `terminal-table` gems installed:

“`sh
gem install daru
gem install terminal-table
“`

2. **Create and Run a Script**:
Below is the script modified to use `terminal-table` for a wider table display:

“`ruby
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Filter results to match the exact SKU
filtered_results = shopping_results.select do |result|
result[:title].include?(“PF-110-6053”)
end

# Prepare data for the dataframe
titles = []
prices = []
links = []

filtered_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe using terminal-table
rows = df.to_a[1..-1] # Extract rows from dataframe, skip header row
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => rows

puts table
“`

### Explanation:
1. **Install Gems**:
Ensure both `daru` and `terminal-table` gems are installed for dataframe handling and table formatting, respectively.

2. **Modify Script**:
The script fetches and filters data as before but uses `terminal-table` to display the results in a wide format.

3. **Create and Display DataFrame**:
Convert the `daru` dataframe to an array and use it to create a `Terminal::Table`. The table is then printed in a more readable format that makes better use of screen width.

### Running the Script

1. Save the script to a file, e.g., `wide_display_google_shopping_search.rb`.
2. Run the script using:
“`sh
ruby wide_display_google_shopping_search.rb
“`

### Output Example

When you run this script, the output will be displayed in a wide format:

“`
+————————————————-+———+——————————-+
| Title | Price | Link |
+————————————————-+———+——————————-+
| PF-110-6053 Automotive Filter | $29.99 | https://example.com/product1 |
| PF-110-6053 Car Engine Filter | $35.50 | https://example.com/product2 |
+————————————————-+———+——————————-+
“`

This approach ensures the table utilizes the full width of your screen for better readability, especially on a 1080p display. If you need any further customization or additional features, feel free to ask!
Got nothing but the headers
It appears the filtered results might be empty or the data is not being correctly processed into the table. Let’s refine the script to ensure that the data is correctly fetched, filtered, and displayed.

### Step-by-Step Guide to Debug and Display Data

1. **Check Search Results**:
Ensure that the search results are being fetched correctly from the API.

2. **Debug the Filtered Results**:
Print the filtered results to verify they contain the expected data.

3. **Use `terminal-table` to Display Data**:
Ensure the data is correctly passed into the table for display.

Here is the refined script with added debug prints to help identify where the issue might be:

“`ruby
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Debug: Print raw search results
puts “Raw search results:”
puts shopping_results.inspect

# Filter results to match the exact SKU
filtered_results = shopping_results.select do |result|
result[:title].include?(“PF-110-6053”)
end

# Debug: Print filtered results
puts “Filtered results:”
puts filtered_results.inspect

# Prepare data for the dataframe
titles = []
prices = []
links = []

filtered_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe using terminal-table
rows = df.to_a[1..-1] # Extract rows from dataframe, skip header row
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => rows

puts table
“`

### Explanation:
1. **Debug Print Statements**:
– Print the raw search results to ensure data is being fetched correctly from the API.
– Print the filtered results to verify that the filtering logic is working as expected.
– Print the prepared data arrays (titles, prices, links) before creating the dataframe.

2. **Create and Display DataFrame**:
Convert the `daru` dataframe to an array and use it to create a `Terminal::Table`. The table is then printed in a wide format.

### Running the Script

1. Save the script to a file, e.g., `debug_wide_display_google_shopping_search.rb`.
2. Run the script using:
“`sh
ruby debug_wide_display_google_shopping_search.rb
“`

### Interpreting the Debug Output

– **Raw Search Results**: Ensure this contains the data you expect.
– **Filtered Results**: Confirm this includes only the items matching “PF-110-6053”.
– **Prepared Data**: Check that titles, prices, and links arrays are populated correctly.

If the debug output shows the correct data but the table still displays only headers, ensure that the data passed to `Terminal::Table` is correctly formatted.

### Additional Tips

– **Ensure API Key Validity**: Verify that the API key used is valid and has not expired.
– **Check Network Issues**: Make sure there are no network issues affecting the API request.

This approach should help you identify and fix the issue where only headers were displayed. If the problem persists, please share the debug output for further assistance.
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Filter results to match the exact SKU
filtered_results = shopping_results.select do |result|
result[:title].include?(“PF-110-6053”)
end

# Prepare data for the dataframe
titles = []
prices = []
links = []

filtered_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe using terminal-table
puts Terminal::Table.new :headings => df.vectors.keys, :rows => df.to_a
To ensure that the script works correctly and displays the results in a table using the full width of your screen, here is a refined version of the script. This version includes debugging steps to ensure the correct data is being fetched and displayed.

### Refined Script with Debugging and Full Table Display

“`ruby
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Debug: Print raw search results
puts “Raw search results:”
puts shopping_results.inspect

# Filter results to match the exact SKU
filtered_results = shopping_results.select do |result|
result[:title].include?(“PF-110-6053”)
end

# Debug: Print filtered results
puts “Filtered results:”
puts filtered_results.inspect

# Prepare data for the dataframe
titles = []
prices = []
links = []

filtered_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Convert dataframe to array for terminal-table
rows = df.to_a[1..-1] # Extract rows from dataframe, skip header row

# Display the dataframe using terminal-table
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => rows
puts table
end
“`

### Explanation:
1. **Debugging Steps**:
– Print raw search results to ensure data is being fetched correctly.
– Print filtered results to verify the filtering logic is working.
– Print prepared data arrays (titles, prices, links) to ensure they are populated.

2. **Check for Empty Results**:
– Before creating the dataframe, check if any results are found. If no results match the SKU, print a message.

3. **Create and Display DataFrame**:
– If there are results, create the dataframe and convert it to an array format suitable for `terminal-table`.
– Display the table with appropriate headings and rows.

### Running the Script

1. Save the script to a file, e.g., `wide_display_google_shopping_search_with_debug.rb`.
2. Run the script using:
“`sh
ruby wide_display_google_shopping_search_with_debug.rb
“`

### Output Example

If the search finds matching items, the output will look something like this:

“`
+—————————————+——–+————————————-+
| Title | Price | Link |
+—————————————+——–+————————————-+
| PF-110-6053 Automotive Part | $29.99 | https://example.com/product1 |
| PF-110-6053 Automotive Model | $35.50 | https://example.com/product2 |
+—————————————+——–+————————————-+
“`

If no matching results are found, the script will print:

“`
No matching results found for PF-110-6053
“`

By following these steps, you can ensure that the search results are correctly filtered and displayed in a wide table format, making full use of your screen width. If you encounter any issues, the debug outputs will help identify where the problem lies.
I want to make the item a variable that will change as the list is read, right now just the variable and I will type the name for now
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’
variable = ProductName
# Define the search parameters with specific SKU
params = {
engine: “google_shopping”,
q: “RA-BIT-TRAY1”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Debug: Print raw search results
puts “Raw search results:”
puts shopping_results.inspect

# Filter results to match the exact SKU
filtered_results = shopping_results.select do |result|
result[:title].include?(variable)
end

# Debug: Print filtered results
puts “Filtered results:”
puts filtered_results.inspect

# Prepare data for the dataframe
titles = []
prices = []
links = []

filtered_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Convert dataframe to array for terminal-table
rows = df.to_a[1..-1] # Extract rows from dataframe, skip header row

# Display the dataframe using terminal-table
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => rows
puts table
end

Let’s refine the script to use a variable for the product name and make sure it can be changed dynamically as needed. Also, we’ll fix a couple of minor issues in your script, such as the proper use of variables and the concatenation in the `puts` statement.

### Refined Script with Variable Product Name

“`ruby
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Variable for the product name
product_name = “RA-BIT-TRAY1”

# Define the search parameters with specific SKU
params = {
engine: “google_shopping”,
q: product_name,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Debug: Print raw search results
puts “Raw search results:”
puts shopping_results.inspect

# Filter results to match the exact SKU
filtered_results = shopping_results.select do |result|
result[:title].include?(product_name)
end

# Debug: Print filtered results
puts “Filtered results:”
puts filtered_results.inspect

# Prepare data for the dataframe
titles = []
prices = []
links = []

filtered_results.each do |result|
titles << result[:title]
prices << result[:price]
links < titles,
“Price” => prices,
“Link” => links
})

# Convert dataframe to array for terminal-table
rows = df.to_a[1..-1] # Extract rows from dataframe, skip header row

# Display the dataframe using terminal-table
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => rows
puts table
end
“`

### Explanation:
1. **Variable for Product Name**:
– The `product_name` variable is used to store the SKU or product name. This variable can be easily modified to search for different products.

2. **Use of Variable in Search Parameters**:
– The `product_name` variable is used in the `params` hash for the search query (`q`).

3. **Filtering Results**:
– The script filters the search results to match the `product_name`.

4. **Debugging Steps**:
– Debug prints are added to verify the raw search results, filtered results, and prepared data arrays.

5. **Check for Empty Results**:
– Before creating the dataframe, the script checks if any results are found and prints an appropriate message if no results match.

6. **Create and Display DataFrame**:
– If results are found, a dataframe is created and displayed using `terminal-table`.

### Running the Script

1. Save the script to a file, e.g., `dynamic_product_search.rb`.
2. Run the script using:
“`sh
ruby dynamic_product_search.rb
“`

### Changing the Product Name

To search for a different product, simply change the value of the `product_name` variable:

“`ruby
# Variable for the product name
product_name = “NEW-PRODUCT-NAME”
“`

Replace `”NEW-PRODUCT-NAME”` with the SKU or product name you want to search for, and then run the script again.

This approach allows you to dynamically change the product being searched for by modifying a single variable, making the script flexible and reusable.
there is more before this but :: Xyp6ZRCujL64BrTt4HwbyozQ4V3G0″, “https://www.newegg.com/p/111-000A-007W6?item=9SIA29PK8U6622&nm_mc=knc-googleadwords&cm_mmc=knc-googleadwords-_-digital+camera+kits-_-sony-_-9SIA29PK8U6622&utm_source=google&utm_medium=organic+shopping&utm_campaign=knc-googleadwords-_-digital+camera+kits-_-sony-_-9SIA29PK8U6622&source=region&srsltid=AfmBOopD9wzzwZ3oC_VQUe-sbthHoAg4cZYhqlYS7gFbUqpMy_aZb_EtQ_A&com_cvv=d30042528f072ba8a22b19c81250437cd47a2f30330f0ed03551c4efdaf3409e”, “https://www.etsy.com/listing/1659218779/rare-pink-sony-cybershot-dsc-w170?gpla=1&gao=1&”]
+——-+——-+——————————+
| Title | Price | Link |
+——-+——-+——+—+—+—+—+—+—+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
+——-+——-+——+—+—+—+—+—+—+

It seems like the script is displaying the index numbers (`0`, `1`, `2`, etc.) instead of the actual titles, prices, and links in the dataframe. This issue might occur if the data extracted from the search results is not correctly processed into the dataframe.

Let’s review the script and ensure that the data is properly extracted and inserted into the dataframe. We’ll also fix any potential issues in the script.

### Refined Script for Displaying DataFrame

“`ruby
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Define the search parameters with specific SKU
params = {
engine: “google_shopping”,
q: “RA-BIT-TRAY1”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Prepare data for the dataframe
titles = shopping_results.map { |result| result[:title] }
prices = shopping_results.map { |result| result[:price] }
links = shopping_results.map { |result| result[:link] }

# Create a dataframe
df = Daru::DataFrame.new({
“Title” => titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe using terminal-table
rows = df.map(&:to_a) # Convert dataframe to array of arrays
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => rows
puts table
“`

### Explanation:
1. **Data Preparation**:
– Use `map` to extract titles, prices, and links from the shopping results into separate arrays.

2. **Create DataFrame**:
– Create a dataframe using Daru with the extracted data.

3. **Display DataFrame**:
– Convert the dataframe to an array of arrays (`rows`) suitable for `terminal-table`.
– Create a `Terminal::Table` with appropriate headings and rows, and then print it.

### Running the Script

1. Save the script to a file, e.g., `display_google_shopping_results.rb`.
2. Run the script using:
“`sh
ruby display_google_shopping_results.rb
“`

This refined script should correctly display the titles, prices, and links in a tabular format using the `terminal-table` gem. If you encounter any issues or need further assistance, feel free to ask!
Now nothing but the raw inventory list and a lot of ——
It seems the data isn’t correctly processed into the dataframe, resulting in the incorrect display. Let’s refine the script to ensure that the data is correctly extracted and inserted into the dataframe for display.

### Refined Script for Correct DataFrame Display

“`ruby
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Define the search parameters with specific SKU
params = {
engine: “google_shopping”,
q: “RA-BIT-TRAY1”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Check if there are any search results
if shopping_results.empty?
puts “No search results found.”
else
# Prepare data for the dataframe
titles = shopping_results.map { |result| result[:title] }
prices = shopping_results.map { |result| result[:price] }
links = shopping_results.map { |result| result[:link] }

# Create a dataframe
df = Daru::DataFrame.new({
“Title” => titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe using terminal-table
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => df.to_a
puts table
end
“`

### Explanation:
1. **Check for Empty Results**:
– Before processing the search results, the script checks if there are any results available. If there are none, it prints a message and exits gracefully.

2. **Data Preparation**:
– Use `map` to extract titles, prices, and links from the shopping results into separate arrays.

3. **Create DataFrame**:
– Create a dataframe using Daru with the extracted data.

4. **Display DataFrame**:
– Create a `Terminal::Table` with appropriate headings and rows, using the dataframe’s vectors and data.
– Print the table.

### Running the Script

1. Save the script to a file, e.g., `display_google_shopping_results.rb`.
2. Run the script using:
“`sh
ruby display_google_shopping_results.rb
“`

This refined script should correctly display the titles, prices, and links in a tabular format using the `terminal-table` gem. If there are no search results, it will print a message indicating so. If you encounter any further issues, feel free to ask!
EveBusinesspricing>ruby daru2.rb
+——-+——-+——————————————————————————————————————————————————————————————————————————————————————————————–+
| Title | Price | Link |
+——-+——-+——+—+—+—+—+—+—+—+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+

| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 |
27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54
| 55 | 56 | 57 | 58 | 59 |
+——-+——-+——+—+—+—+—+—+—+—+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+—-+

It seems like the table is displaying index numbers instead of the actual data from the dataframe. This issue can occur if there is a problem with the data insertion into the dataframe or with the display settings.

Let’s refine the script to ensure that the data is correctly processed and displayed in the table.

### Refined Script for Correct DataFrame Display

“`ruby
require ‘google_search_results’
require ‘daru’
require ‘terminal-table’

# Define the search parameters with specific SKU
params = {
engine: “google_shopping”,
q: “RA-BIT-TRAY1”,
api_key: “0d17888ebb6912c39b6abb5c18b3cc183691deee6fb444bb7aa5e9fd22772a7c”
}

# Perform the search
search = GoogleSearch.new(params)
shopping_results = search.get_hash[:shopping_results]

# Create a dataframe
df = Daru::DataFrame.new({
“Title” => titles,
“Price” => prices,
“Link” => links
})

# Display the dataframe using terminal-table
table = Terminal::Table.new :headings => df.vectors.to_a, :rows => df.to_a[1..-1]
puts table
end
“`

### Explanation:
– We’ve adjusted the `rows` variable to skip the header row when converting the dataframe to an array of arrays. This ensures that only the data rows are included in the table.

### Running the Script

1. Save the script to a file, e.g., `display_google_shopping_results.rb`.
2. Run the script using:
“`sh
ruby display_google_shopping_results.rb
“`