Implemented Automatic Detection of chip counts and colors # 7 #25
2
.gitignore
vendored
@ -36,3 +36,5 @@ yarn-error.*
|
||||
*.tsbuildinfo
|
||||
|
||||
app-example
|
||||
android
|
||||
.env
|
3
app.json
@ -15,7 +15,8 @@
|
||||
"adaptiveIcon": {
|
||||
"foregroundImage": "./assets/images/adaptive-icon.png",
|
||||
"backgroundColor": "#ffffff"
|
||||
}
|
||||
},
|
||||
"package": "com.anonymous.pokerchipshelper"
|
||||
},
|
||||
"web": {
|
||||
"bundler": "metro",
|
||||
|
@ -5,11 +5,13 @@ import BuyInSelector from "@/components/BuyInSelector";
|
||||
import ChipsSelector from "@/components/ChipsSelector";
|
||||
import ChipDistributionSummary from "@/components/ChipDistributionSummary";
|
||||
import ChipDetection from "@/components/ChipDetection";
|
||||
|
||||
const IndexScreen = () => {
|
||||
const [playerCount, setPlayerCount] = useState(2);
|
||||
const [buyInAmount, setBuyInAmount] = useState<number | null>(null);
|
||||
const [numberOfChips, setNumberOfChips] = useState<number>(5);
|
||||
const [totalChipsCount, setTotalChipsCount] = useState<number[]>([]);
|
||||
|
||||
const handleSave = () => {
|
||||
if (buyInAmount === null) {
|
||||
Alert.alert("Error", "Please select a valid buy-in amount");
|
||||
@ -20,6 +22,16 @@ const IndexScreen = () => {
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
// Update chip count based on detection or manual edit
|
||||
const updateChipCount = (chipData: { [color: string]: number }) => {
|
||||
// Convert the chip data from the API response or manual edit to a count array
|
||||
const chipCountArray = Object.entries(chipData).map(
|
||||
([color, count]) => count
|
||||
);
|
||||
setTotalChipsCount(chipCountArray); // Update the parent component's state
|
||||
};
|
||||
|
||||
return (
|
||||
<ScrollView contentContainerStyle={{ padding: 20, flexGrow: 1 }}>
|
||||
<Text style={{ fontSize: 24, marginBottom: 30, marginTop: 50 }}>
|
||||
@ -30,10 +42,7 @@ const IndexScreen = () => {
|
||||
setPlayerCount={setPlayerCount}
|
||||
/>
|
||||
<BuyInSelector setBuyInAmount={setBuyInAmount} />
|
||||
<ChipDetection
|
||||
totalChipsCount={totalChipsCount}
|
||||
setTotalChipsCount={setTotalChipsCount}
|
||||
/>
|
||||
<ChipDetection updateChipCount={updateChipCount} />
|
||||
<ChipsSelector
|
||||
totalChipsCount={totalChipsCount}
|
||||
setTotalChipsCount={setTotalChipsCount}
|
||||
@ -53,4 +62,5 @@ const IndexScreen = () => {
|
||||
</ScrollView>
|
||||
);
|
||||
};
|
||||
|
||||
export default IndexScreen;
|
||||
|
14
babel.config.js
Normal file
@ -0,0 +1,14 @@
|
||||
module.exports = {
|
||||
presets: ["module:metro-react-native-babel-preset"],
|
||||
plugins: [
|
||||
[
|
||||
"module:react-native-dotenv",
|
||||
{
|
||||
moduleName: "@env",
|
||||
path: ".env",
|
||||
safe: true,
|
||||
allowUndefined: false,
|
||||
},
|
||||
],
|
||||
],
|
||||
};
|
@ -1,46 +1,137 @@
|
||||
|
||||
import React, { useState } from "react";
|
||||
import { View, Text } from "react-native";
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
import { MaterialIcons } from "@expo/vector-icons";
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
import {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
View,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
Button,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
Image,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
ActivityIndicator,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
Text,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
ScrollView,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
} from "react-native";
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
import * as ImagePicker from "expo-image-picker";
|
||||
import { API_KEY } from "@env";
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
/**
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
The best way forward for this component is likely to send the image chosen to an AI + NLP API.
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
Google cloud vision is likely a good choice, as I think it offers some sort of free tier or trial usage for free, as long as it can also support NLP prompts
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
We need to thoughtfully prompt the API and ask it to return data in a well formatted JSON, or return an error if the image supplied is unable to be read, or otherwise out of context
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
We could also ask it to return a "confidence" level as a percentage, if the user may find that helpful
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const ChipDetection = ({ updateChipCount }) => {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const [imageUri, setImageUri] = useState(null);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const [loading, setLoading] = useState(false);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const [error, setError] = useState(null);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const [lastDetectedChips, setLastDetectedChips] = useState({});
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
*/
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
// Ensure early return does not break hooks
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const requestCameraPermissions = async () => {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const cameraPermission = await ImagePicker.requestCameraPermissionsAsync();
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
return cameraPermission.granted;
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
};
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
const ChipDetection = ({
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
totalChipsCount,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setTotalChipsCount,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}: {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
totalChipsCount: number[];
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setTotalChipsCount: React.Dispatch<React.SetStateAction<number[]>>;
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}) => {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const [image, setImage] = useState<any>(null);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const pickImage = async () => {
|
||||
const { status } = await ImagePicker.requestMediaLibraryPermissionsAsync();
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
if (status !== "granted") {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
alert("Permission denied!");
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
return;
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const result = await ImagePicker.launchCameraAsync({
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
allowsEditing: true,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const result = await ImagePicker.launchImageLibraryAsync({
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
mediaTypes: ImagePicker.MediaTypeOptions.Images,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
base64: true,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
quality: 1,
|
||||
});
|
||||
|
||||
if (!result.canceled) {
|
||||
setImage(result.assets[0].uri);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setImageUri(result.assets[0].uri);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
await processImage(result.assets[0].base64);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}
|
||||
};
|
||||
|
||||
const takePhoto = async () => {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const hasPermission = await requestCameraPermissions();
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
if (!hasPermission) {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setError("Camera permission is required to take a photo.");
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
return;
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const result = await ImagePicker.launchCameraAsync({
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
base64: true,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
quality: 1,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
});
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
if (!result.canceled) {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setImageUri(result.assets[0].uri);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
await processImage(result.assets[0].base64);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
};
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const processImage = async (base64Image) => {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setLoading(true);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setError(null);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
try {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const response = await fetch(
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
"https://api.openai.com/v1/chat/completions",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
method: "POST",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
headers: {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
Authorization: `Bearer ${API_KEY}`,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
"Content-Type": "application/json",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
},
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
body: JSON.stringify({
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
model: "gpt-4o-mini",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
messages: [
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
role: "system",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
content:
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
"Identify and count poker chips by color. Return only the count for each color in JSON format.",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
},
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
role: "user",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
content: [
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
type: "text",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
text: "How many poker chips are there for each color? Return structured JSON.",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
},
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
type: "image_url",
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
image_url: { url: `data:image/png;base64,${base64Image}` },
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
},
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
],
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
},
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
],
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
max_tokens: 1000,
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}),
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const result = await response.json();
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
if (!response.ok || !result.choices || !result.choices[0].message) {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
throw new Error("Invalid response from API.");
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const rawContent = result.choices[0].message.content.trim();
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const cleanJSON = rawContent.replace(/```json|```/g, "").trim();
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const parsedData = JSON.parse(cleanJSON);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
// Filter out colors with a count of 0
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
const filteredData = Object.fromEntries(
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
Object.entries(parsedData).filter(([_, count]) => count > 0)
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setLastDetectedChips(filteredData); // Store detected chip counts
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
updateChipCount(filteredData);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
} catch (error) {
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
console.error("Error processing image:", error);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setError("Failed to analyze the image.");
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
setLoading(false);
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
};
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
return (
|
||||
<View>
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
<Text> Automatic Detection</Text>
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
<MaterialIcons name="camera-alt" onPress={pickImage} size={30} />
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
</View>
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
<ScrollView contentContainerStyle={{ padding: 20, alignItems: "center" }}>
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
<Button title="Pick an Image" onPress={pickImage} />
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
<Button title="Take a Photo" onPress={takePhoto} />
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{imageUri && (
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
<Image
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
source={{ uri: imageUri }}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
style={{ width: 300, height: 300, marginTop: 10 }}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
/>
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
)}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{loading && <ActivityIndicator size="large" color="blue" />}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
{error && <Text style={{ color: "red", marginTop: 10 }}>{error}</Text>}
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
</ScrollView>
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
|
||||
);
|
||||
};
|
||||
|
||||
|
||||
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() I think it would be good to make this an You can resolve this comment when done I think it would be good to make this an `env` variable, like the API key.
That way we can change the model on-the-fly easier
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Now that we have environment variables using
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
You can resolve this comment when done Now that we have environment variables using `dotenv`, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion
1. Create and commit a file at the root called `.env.example` This file will might look similar to
```
API_KEY={Put Open AI key here}
GPT_MODEL=gpt-4o-mini
#GPT_MODEL=gpt-4-turbo # More expensive model, use sparingly
```
The purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
2. Update the README.md with a section under the build/run, for how to populate `.env`. Essentially we instruct the developer to copy the `.env.example` with the new name `.env` (`cp .env.example .env`) and to paste their api key.
You can resolve this comment when done
![]() Do you mean the link? Do you mean the link?
![]() Do you mean the link? Do you mean the link?
|
@ -9,7 +9,7 @@ interface ChipDistributionSummaryProps {
|
||||
colors?: ColorValue[];
|
||||
}
|
||||
|
||||
const MAX_CHIPS = 500;
|
||||
const MAX_CHIPS = 500;
|
||||
|
||||
const ChipDistributionSummary = ({
|
||||
playerCount,
|
||||
@ -22,16 +22,18 @@ const ChipDistributionSummary = ({
|
||||
useEffect(() => {
|
||||
if (buyInAmount !== null && playerCount > 0) {
|
||||
let totalChips = totalChipsCount.reduce((sum, count) => sum + count, 0);
|
||||
|
||||
|
||||
if (totalChips > MAX_CHIPS) {
|
||||
const scaleFactor = MAX_CHIPS / totalChips;
|
||||
totalChipsCount = totalChipsCount.map((count) => Math.floor(count * scaleFactor));
|
||||
totalChipsCount = totalChipsCount.map((count) =>
|
||||
Math.floor(count * scaleFactor)
|
||||
);
|
||||
totalChips = MAX_CHIPS;
|
||||
}
|
||||
const distribution = totalChipsCount.map((chipCount) =>
|
||||
Math.floor(chipCount / playerCount)
|
||||
);
|
||||
|
||||
|
||||
setChipDistribution(distribution);
|
||||
} else {
|
||||
setChipDistribution([]);
|
||||
@ -49,12 +51,14 @@ const ChipDistributionSummary = ({
|
||||
<Text style={styles.title}>Chip Distribution Summary:</Text>
|
||||
{hasValidDistribution ? (
|
||||
chipDistribution.map((count, index) => (
|
||||
<Text key={index} style={[styles.chipText, { color: colors[index] }]}>
|
||||
{`${colors[index]?.toString().toUpperCase()} Chips: ${count} per player`}
|
||||
<Text key={index} style={[styles.chipText, { color: colors[index] }]}>
|
||||
{`${colors[index]?.toString().toUpperCase()} Chips: ${count} per player`}
|
||||
</Text>
|
||||
))
|
||||
) : (
|
||||
<Text style={styles.noDataText}>No valid distribution calculated yet.</Text>
|
||||
<Text style={styles.noDataText}>
|
||||
No valid distribution calculated yet.
|
||||
</Text>
|
||||
)}
|
||||
</View>
|
||||
);
|
||||
@ -82,4 +86,4 @@ const styles = StyleSheet.create({
|
||||
},
|
||||
});
|
||||
|
||||
export default ChipDistributionSummary;
|
||||
export default ChipDistributionSummary;
|
||||
|
670
package-lock.json
generated
@ -11,11 +11,15 @@
|
||||
"@expo/vector-icons": "^14.0.2",
|
||||
"@react-navigation/bottom-tabs": "^7.2.0",
|
||||
"@react-navigation/native": "^7.0.14",
|
||||
"@tensorflow/tfjs": "^4.22.0",
|
||||
"@tensorflow/tfjs-react-native": "^1.0.0",
|
||||
"expo": "~52.0.31",
|
||||
"expo-blur": "~14.0.3",
|
||||
"expo-constants": "~17.0.5",
|
||||
"expo-file-system": "~18.0.11",
|
||||
"expo-font": "~13.0.3",
|
||||
"expo-haptics": "~14.0.1",
|
||||
"expo-image-picker": "~16.0.6",
|
||||
"expo-linking": "~7.0.5",
|
||||
"expo-router": "~4.0.17",
|
||||
"expo-splash-screen": "~0.29.21",
|
||||
@ -23,9 +27,11 @@
|
||||
"expo-symbols": "~0.2.2",
|
||||
"expo-system-ui": "~4.0.8",
|
||||
"expo-web-browser": "~14.0.2",
|
||||
"metro-react-native-babel-preset": "^0.77.0",
|
||||
"react": "18.3.1",
|
||||
"react-dom": "18.3.1",
|
||||
"react-native": "0.76.7",
|
||||
"react-native-dotenv": "^3.4.11",
|
||||
"react-native-gesture-handler": "~2.20.2",
|
||||
"react-native-reanimated": "~3.16.1",
|
||||
"react-native-safe-area-context": "4.12.0",
|
||||
@ -232,6 +238,18 @@
|
||||
"@babel/core": "^7.4.0 || ^8.0.0-0 <8.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/helper-environment-visitor": {
|
||||
"version": "7.24.7",
|
||||
"resolved": "https://registry.npmjs.org/@babel/helper-environment-visitor/-/helper-environment-visitor-7.24.7.tgz",
|
||||
"integrity": "sha512-DoiN84+4Gnd0ncbBOM9AZENV4a5ZiL39HYMyZJGZ/AZEykHYdJw0wW3kdcsh9/Kn+BRXHLkkklZ51ecPKmI1CQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/types": "^7.24.7"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/helper-member-expression-to-functions": {
|
||||
"version": "7.25.9",
|
||||
"resolved": "https://registry.npmjs.org/@babel/helper-member-expression-to-functions/-/helper-member-expression-to-functions-7.25.9.tgz",
|
||||
@ -582,6 +600,25 @@
|
||||
"@babel/core": "^7.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/plugin-proposal-async-generator-functions": {
|
||||
"version": "7.20.7",
|
||||
"resolved": "https://registry.npmjs.org/@babel/plugin-proposal-async-generator-functions/-/plugin-proposal-async-generator-functions-7.20.7.tgz",
|
||||
"integrity": "sha512-xMbiLsn/8RK7Wq7VeVytytS2L6qE69bXPB10YCmMdDZbKF4okCqY74pI/jJQ/8U0b/F6NrT2+14b8/P9/3AMGA==",
|
||||
"deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-async-generator-functions instead.",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/helper-environment-visitor": "^7.18.9",
|
||||
"@babel/helper-plugin-utils": "^7.20.2",
|
||||
"@babel/helper-remap-async-to-generator": "^7.18.9",
|
||||
"@babel/plugin-syntax-async-generators": "^7.8.4"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@babel/core": "^7.0.0-0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/plugin-proposal-class-properties": {
|
||||
"version": "7.18.6",
|
||||
"resolved": "https://registry.npmjs.org/@babel/plugin-proposal-class-properties/-/plugin-proposal-class-properties-7.18.6.tgz",
|
||||
@ -648,6 +685,60 @@
|
||||
"@babel/core": "^7.0.0-0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/plugin-proposal-numeric-separator": {
|
||||
"version": "7.18.6",
|
||||
"resolved": "https://registry.npmjs.org/@babel/plugin-proposal-numeric-separator/-/plugin-proposal-numeric-separator-7.18.6.tgz",
|
||||
"integrity": "sha512-ozlZFogPqoLm8WBr5Z8UckIoE4YQ5KESVcNudyXOR8uqIkliTEgJ3RoketfG6pmzLdeZF0H/wjE9/cCEitBl7Q==",
|
||||
"deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-numeric-separator instead.",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/helper-plugin-utils": "^7.18.6",
|
||||
"@babel/plugin-syntax-numeric-separator": "^7.10.4"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@babel/core": "^7.0.0-0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/plugin-proposal-object-rest-spread": {
|
||||
"version": "7.20.7",
|
||||
"resolved": "https://registry.npmjs.org/@babel/plugin-proposal-object-rest-spread/-/plugin-proposal-object-rest-spread-7.20.7.tgz",
|
||||
"integrity": "sha512-d2S98yCiLxDVmBmE8UjGcfPvNEUbA1U5q5WxaWFUGRzJSVAZqm5W6MbPct0jxnegUZ0niLeNX+IOzEs7wYg9Dg==",
|
||||
"deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-object-rest-spread instead.",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/compat-data": "^7.20.5",
|
||||
"@babel/helper-compilation-targets": "^7.20.7",
|
||||
"@babel/helper-plugin-utils": "^7.20.2",
|
||||
"@babel/plugin-syntax-object-rest-spread": "^7.8.3",
|
||||
"@babel/plugin-transform-parameters": "^7.20.7"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@babel/core": "^7.0.0-0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/plugin-proposal-optional-catch-binding": {
|
||||
"version": "7.18.6",
|
||||
"resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-catch-binding/-/plugin-proposal-optional-catch-binding-7.18.6.tgz",
|
||||
"integrity": "sha512-Q40HEhs9DJQyaZfUjjn6vE8Cv4GmMHCYuMGIWUnlxH6400VGxOuwWsPt4FxXxJkC/5eOzgn0z21M9gMT4MOhbw==",
|
||||
"deprecated": "This proposal has been merged to the ECMAScript standard and thus this plugin is no longer maintained. Please use @babel/plugin-transform-optional-catch-binding instead.",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/helper-plugin-utils": "^7.18.6",
|
||||
"@babel/plugin-syntax-optional-catch-binding": "^7.8.3"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=6.9.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@babel/core": "^7.0.0-0"
|
||||
}
|
||||
},
|
||||
"node_modules/@babel/plugin-proposal-optional-chaining": {
|
||||
"version": "7.21.0",
|
||||
"resolved": "https://registry.npmjs.org/@babel/plugin-proposal-optional-chaining/-/plugin-proposal-optional-chaining-7.21.0.tgz",
|
||||
@ -3856,6 +3947,19 @@
|
||||
"react": "^16.8 || ^17.0 || ^18.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@react-native-async-storage/async-storage": {
|
||||
"version": "1.24.0",
|
||||
"resolved": "https://registry.npmjs.org/@react-native-async-storage/async-storage/-/async-storage-1.24.0.tgz",
|
||||
"integrity": "sha512-W4/vbwUOYOjco0x3toB8QCr7EjIP6nE9G7o8PMguvvjYT5Awg09lyV4enACRx4s++PPulBiBSjL0KTFx2u0Z/g==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"merge-options": "^3.0.4"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"react-native": "^0.0.0-0 || >=0.60 <1.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@react-native/assets-registry": {
|
||||
"version": "0.76.7",
|
||||
"resolved": "https://registry.npmjs.org/@react-native/assets-registry/-/assets-registry-0.76.7.tgz",
|
||||
@ -4480,6 +4584,301 @@
|
||||
"@sinonjs/commons": "^3.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs": {
|
||||
"version": "4.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs/-/tfjs-4.22.0.tgz",
|
||||
"integrity": "sha512-0TrIrXs6/b7FLhLVNmfh8Sah6JgjBPH4mZ8JGb7NU6WW+cx00qK5BcAZxw7NCzxj6N8MRAIfHq+oNbPUNG5VAg==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"@tensorflow/tfjs-backend-cpu": "4.22.0",
|
||||
"@tensorflow/tfjs-backend-webgl": "4.22.0",
|
||||
"@tensorflow/tfjs-converter": "4.22.0",
|
||||
"@tensorflow/tfjs-core": "4.22.0",
|
||||
"@tensorflow/tfjs-data": "4.22.0",
|
||||
"@tensorflow/tfjs-layers": "4.22.0",
|
||||
"argparse": "^1.0.10",
|
||||
"chalk": "^4.1.0",
|
||||
"core-js": "3.29.1",
|
||||
"regenerator-runtime": "^0.13.5",
|
||||
"yargs": "^16.0.3"
|
||||
},
|
||||
"bin": {
|
||||
"tfjs-custom-module": "dist/tools/custom_module/cli.js"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-backend-cpu": {
|
||||
"version": "4.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs-backend-cpu/-/tfjs-backend-cpu-4.22.0.tgz",
|
||||
"integrity": "sha512-1u0FmuLGuRAi8D2c3cocHTASGXOmHc/4OvoVDENJayjYkS119fcTcQf4iHrtLthWyDIPy3JiPhRrZQC9EwnhLw==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"@types/seedrandom": "^2.4.28",
|
||||
"seedrandom": "^3.0.5"
|
||||
},
|
||||
"engines": {
|
||||
"yarn": ">= 1.3.2"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@tensorflow/tfjs-core": "4.22.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-backend-webgl": {
|
||||
"version": "4.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs-backend-webgl/-/tfjs-backend-webgl-4.22.0.tgz",
|
||||
"integrity": "sha512-H535XtZWnWgNwSzv538czjVlbJebDl5QTMOth4RXr2p/kJ1qSIXE0vZvEtO+5EC9b00SvhplECny2yDewQb/Yg==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"@tensorflow/tfjs-backend-cpu": "4.22.0",
|
||||
"@types/offscreencanvas": "~2019.3.0",
|
||||
"@types/seedrandom": "^2.4.28",
|
||||
"seedrandom": "^3.0.5"
|
||||
},
|
||||
"engines": {
|
||||
"yarn": ">= 1.3.2"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@tensorflow/tfjs-core": "4.22.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-converter": {
|
||||
"version": "4.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs-converter/-/tfjs-converter-4.22.0.tgz",
|
||||
"integrity": "sha512-PT43MGlnzIo+YfbsjM79Lxk9lOq6uUwZuCc8rrp0hfpLjF6Jv8jS84u2jFb+WpUeuF4K33ZDNx8CjiYrGQ2trQ==",
|
||||
"license": "Apache-2.0",
|
||||
"peerDependencies": {
|
||||
"@tensorflow/tfjs-core": "4.22.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-core": {
|
||||
"version": "4.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs-core/-/tfjs-core-4.22.0.tgz",
|
||||
"integrity": "sha512-LEkOyzbknKFoWUwfkr59vSB68DMJ4cjwwHgicXN0DUi3a0Vh1Er3JQqCI1Hl86GGZQvY8ezVrtDIvqR1ZFW55A==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"@types/long": "^4.0.1",
|
||||
"@types/offscreencanvas": "~2019.7.0",
|
||||
"@types/seedrandom": "^2.4.28",
|
||||
"@webgpu/types": "0.1.38",
|
||||
"long": "4.0.0",
|
||||
"node-fetch": "~2.6.1",
|
||||
"seedrandom": "^3.0.5"
|
||||
},
|
||||
"engines": {
|
||||
"yarn": ">= 1.3.2"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-core/node_modules/@types/offscreencanvas": {
|
||||
"version": "2019.7.3",
|
||||
"resolved": "https://registry.npmjs.org/@types/offscreencanvas/-/offscreencanvas-2019.7.3.tgz",
|
||||
"integrity": "sha512-ieXiYmgSRXUDeOntE1InxjWyvEelZGP63M+cGuquuRLuIKKT1osnkXjxev9B7d1nXSug5vpunx+gNlbVxMlC9A==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-core/node_modules/node-fetch": {
|
||||
"version": "2.6.13",
|
||||
"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.13.tgz",
|
||||
"integrity": "sha512-StxNAxh15zr77QvvkmveSQ8uCQ4+v5FkvNTj0OESmiHu+VRi/gXArXtkWMElOsOUNLtUEvI4yS+rdtOHZTwlQA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"whatwg-url": "^5.0.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": "4.x || >=6.0.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"encoding": "^0.1.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"encoding": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-core/node_modules/tr46": {
|
||||
"version": "0.0.3",
|
||||
"resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
|
||||
"integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-core/node_modules/webidl-conversions": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
|
||||
"integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
|
||||
"license": "BSD-2-Clause"
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-core/node_modules/whatwg-url": {
|
||||
"version": "5.0.0",
|
||||
"resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
|
||||
"integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"tr46": "~0.0.3",
|
||||
"webidl-conversions": "^3.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-data": {
|
||||
"version": "4.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs-data/-/tfjs-data-4.22.0.tgz",
|
||||
"integrity": "sha512-dYmF3LihQIGvtgJrt382hSRH4S0QuAp2w1hXJI2+kOaEqo5HnUPG0k5KA6va+S1yUhx7UBToUKCBHeLHFQRV4w==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"@types/node-fetch": "^2.1.2",
|
||||
"node-fetch": "~2.6.1",
|
||||
"string_decoder": "^1.3.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@tensorflow/tfjs-core": "4.22.0",
|
||||
"seedrandom": "^3.0.5"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-data/node_modules/node-fetch": {
|
||||
"version": "2.6.13",
|
||||
"resolved": "https://registry.npmjs.org/node-fetch/-/node-fetch-2.6.13.tgz",
|
||||
"integrity": "sha512-StxNAxh15zr77QvvkmveSQ8uCQ4+v5FkvNTj0OESmiHu+VRi/gXArXtkWMElOsOUNLtUEvI4yS+rdtOHZTwlQA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"whatwg-url": "^5.0.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": "4.x || >=6.0.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"encoding": "^0.1.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"encoding": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-data/node_modules/tr46": {
|
||||
"version": "0.0.3",
|
||||
"resolved": "https://registry.npmjs.org/tr46/-/tr46-0.0.3.tgz",
|
||||
"integrity": "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-data/node_modules/webidl-conversions": {
|
||||
"version": "3.0.1",
|
||||
"resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-3.0.1.tgz",
|
||||
"integrity": "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ==",
|
||||
"license": "BSD-2-Clause"
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-data/node_modules/whatwg-url": {
|
||||
"version": "5.0.0",
|
||||
"resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-5.0.0.tgz",
|
||||
"integrity": "sha512-saE57nupxk6v3HY35+jzBwYa0rKSy0XR8JSxZPwgLr7ys0IBzhGviA1/TUGJLmSVqs8pb9AnvICXEuOHLprYTw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"tr46": "~0.0.3",
|
||||
"webidl-conversions": "^3.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-layers": {
|
||||
"version": "4.22.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs-layers/-/tfjs-layers-4.22.0.tgz",
|
||||
"integrity": "sha512-lybPj4ZNj9iIAPUj7a8ZW1hg8KQGfqWLlCZDi9eM/oNKCCAgchiyzx8OrYoWmRrB+AM6VNEeIT+2gZKg5ReihA==",
|
||||
"license": "Apache-2.0 AND MIT",
|
||||
"peerDependencies": {
|
||||
"@tensorflow/tfjs-core": "4.22.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs-react-native": {
|
||||
"version": "1.0.0",
|
||||
"resolved": "https://registry.npmjs.org/@tensorflow/tfjs-react-native/-/tfjs-react-native-1.0.0.tgz",
|
||||
"integrity": "sha512-YzzJeb6ZDtCNBRvwKKQwASfcd0zIP8DWkQJyOlQPzJS/XIMMK1Qxf6LVLDpNoOC4FGdFd4QoGD6AvmU9gSUrHg==",
|
||||
"license": "Apache-2.0",
|
||||
"dependencies": {
|
||||
"base64-js": "^1.3.0",
|
||||
"buffer": "^5.2.1",
|
||||
"jpeg-js": "^0.4.3"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@react-native-async-storage/async-storage": "^1.13.0",
|
||||
"@tensorflow/tfjs-backend-cpu": "^4.13.0",
|
||||
"@tensorflow/tfjs-backend-webgl": "^4.13.0",
|
||||
"@tensorflow/tfjs-core": "^4.13.0",
|
||||
"expo-camera": "^13.4.4",
|
||||
"expo-gl": "^13.0.1",
|
||||
"react": "*",
|
||||
"react-native": ">= 0.72.0",
|
||||
"react-native-fs": "^2.20.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs/node_modules/cliui": {
|
||||
"version": "7.0.4",
|
||||
"resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
|
||||
"integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
|
||||
"license": "ISC",
|
||||
"dependencies": {
|
||||
"string-width": "^4.2.0",
|
||||
"strip-ansi": "^6.0.0",
|
||||
"wrap-ansi": "^7.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs/node_modules/emoji-regex": {
|
||||
"version": "8.0.0",
|
||||
"resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",
|
||||
"integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs/node_modules/regenerator-runtime": {
|
||||
"version": "0.13.11",
|
||||
"resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.13.11.tgz",
|
||||
"integrity": "sha512-kY1AZVr2Ra+t+piVaJ4gxaFaReZVH40AKNo7UCX6W+dEwBo/2oZJzqfuN1qLq1oL45o56cPaTXELwrTh8Fpggg==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs/node_modules/string-width": {
|
||||
"version": "4.2.3",
|
||||
"resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",
|
||||
"integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"emoji-regex": "^8.0.0",
|
||||
"is-fullwidth-code-point": "^3.0.0",
|
||||
"strip-ansi": "^6.0.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=8"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs/node_modules/strip-ansi": {
|
||||
"version": "6.0.1",
|
||||
"resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",
|
||||
"integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"ansi-regex": "^5.0.1"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=8"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs/node_modules/yargs": {
|
||||
"version": "16.2.0",
|
||||
"resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
|
||||
"integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"cliui": "^7.0.2",
|
||||
"escalade": "^3.1.1",
|
||||
"get-caller-file": "^2.0.5",
|
||||
"require-directory": "^2.1.1",
|
||||
"string-width": "^4.2.0",
|
||||
"y18n": "^5.0.5",
|
||||
"yargs-parser": "^20.2.2"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=10"
|
||||
}
|
||||
},
|
||||
"node_modules/@tensorflow/tfjs/node_modules/yargs-parser": {
|
||||
"version": "20.2.9",
|
||||
"resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz",
|
||||
"integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==",
|
||||
"license": "ISC",
|
||||
"engines": {
|
||||
"node": ">=10"
|
||||
}
|
||||
},
|
||||
"node_modules/@testing-library/dom": {
|
||||
"version": "10.4.0",
|
||||
"resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.0.tgz",
|
||||
@ -4773,6 +5172,12 @@
|
||||
"integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@types/long": {
|
||||
"version": "4.0.2",
|
||||
"resolved": "https://registry.npmjs.org/@types/long/-/long-4.0.2.tgz",
|
||||
"integrity": "sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@types/node": {
|
||||
"version": "22.13.1",
|
||||
"resolved": "https://registry.npmjs.org/@types/node/-/node-22.13.1.tgz",
|
||||
@ -4782,6 +5187,31 @@
|
||||
"undici-types": "~6.20.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/node-fetch": {
|
||||
"version": "2.6.12",
|
||||
"resolved": "https://registry.npmjs.org/@types/node-fetch/-/node-fetch-2.6.12.tgz",
|
||||
"integrity": "sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@types/node": "*",
|
||||
"form-data": "^4.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/node-fetch/node_modules/form-data": {
|
||||
"version": "4.0.2",
|
||||
"resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.2.tgz",
|
||||
"integrity": "sha512-hGfm/slu0ZabnNt4oaRZ6uREyfCj6P4fT/n6A1rGV+Z0VdGXjfOhVUpkn6qVQONHGIFwmveGXyDs75+nr6FM8w==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"asynckit": "^0.4.0",
|
||||
"combined-stream": "^1.0.8",
|
||||
"es-set-tostringtag": "^2.1.0",
|
||||
"mime-types": "^2.1.12"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 6"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/node-forge": {
|
||||
"version": "1.3.11",
|
||||
"resolved": "https://registry.npmjs.org/@types/node-forge/-/node-forge-1.3.11.tgz",
|
||||
@ -4791,6 +5221,12 @@
|
||||
"@types/node": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/offscreencanvas": {
|
||||
"version": "2019.3.0",
|
||||
"resolved": "https://registry.npmjs.org/@types/offscreencanvas/-/offscreencanvas-2019.3.0.tgz",
|
||||
"integrity": "sha512-esIJx9bQg+QYF0ra8GnvfianIY8qWB0GBx54PK5Eps6m+xTj86KLavHv6qDhzKcu5UUOgNfJ2pWaIIV7TRUd9Q==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@types/prop-types": {
|
||||
"version": "15.7.14",
|
||||
"resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.14.tgz",
|
||||
@ -4819,6 +5255,12 @@
|
||||
"@types/react": "^18"
|
||||
}
|
||||
},
|
||||
"node_modules/@types/seedrandom": {
|
||||
"version": "2.4.34",
|
||||
"resolved": "https://registry.npmjs.org/@types/seedrandom/-/seedrandom-2.4.34.tgz",
|
||||
"integrity": "sha512-ytDiArvrn/3Xk6/vtylys5tlY6eo7Ane0hvcx++TKo6RxQXuVfW0AF/oeWqAj9dN29SyhtawuXstgmPlwNcv/A==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@types/stack-utils": {
|
||||
"version": "2.0.3",
|
||||
"resolved": "https://registry.npmjs.org/@types/stack-utils/-/stack-utils-2.0.3.tgz",
|
||||
@ -5052,6 +5494,12 @@
|
||||
"@xtuc/long": "4.2.2"
|
||||
}
|
||||
},
|
||||
"node_modules/@webgpu/types": {
|
||||
"version": "0.1.38",
|
||||
"resolved": "https://registry.npmjs.org/@webgpu/types/-/types-0.1.38.tgz",
|
||||
"integrity": "sha512-7LrhVKz2PRh+DD7+S+PVaFd5HxaWQvoMqBbsV9fNJO1pjUs1P8bM2vQVNfk+3URTqbuTI7gkXi0rfsN0IadoBA==",
|
||||
"license": "BSD-3-Clause"
|
||||
},
|
||||
"node_modules/@xmldom/xmldom": {
|
||||
"version": "0.7.13",
|
||||
"resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.7.13.tgz",
|
||||
@ -5796,6 +6244,12 @@
|
||||
"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/base-64": {
|
||||
"version": "0.1.0",
|
||||
"resolved": "https://registry.npmjs.org/base-64/-/base-64-0.1.0.tgz",
|
||||
"integrity": "sha512-Y5gU45svrR5tI2Vt/X9GPd3L0HNIKzGu202EjxrXMpuc2V2CiKgemAbUUsqYmZJvPtCXoUKjNZwBJzsNScUbXA==",
|
||||
"peer": true
|
||||
},
|
||||
"node_modules/base64-js": {
|
||||
"version": "1.5.1",
|
||||
"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
|
||||
@ -6591,6 +7045,17 @@
|
||||
"node": ">=6.6.0"
|
||||
}
|
||||
},
|
||||
"node_modules/core-js": {
|
||||
"version": "3.29.1",
|
||||
"resolved": "https://registry.npmjs.org/core-js/-/core-js-3.29.1.tgz",
|
||||
"integrity": "sha512-+jwgnhg6cQxKYIIjGtAHq2nwUOolo9eoFZ4sHfUH09BLXBgxnH4gA0zEd+t+BO2cNB8idaBtZFcFTRjQJRJmAw==",
|
||||
"hasInstallScript": true,
|
||||
"license": "MIT",
|
||||
"funding": {
|
||||
"type": "opencollective",
|
||||
"url": "https://opencollective.com/core-js"
|
||||
}
|
||||
},
|
||||
"node_modules/core-js-compat": {
|
||||
"version": "3.40.0",
|
||||
"resolved": "https://registry.npmjs.org/core-js-compat/-/core-js-compat-3.40.0.tgz",
|
||||
@ -7389,7 +7854,6 @@
|
||||
"version": "2.1.0",
|
||||
"resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
|
||||
"integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
|
||||
"dev": true,
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"es-errors": "^1.3.0",
|
||||
@ -8060,6 +8524,19 @@
|
||||
"react-native": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/expo-camera": {
|
||||
"version": "13.9.0",
|
||||
"resolved": "https://registry.npmjs.org/expo-camera/-/expo-camera-13.9.0.tgz",
|
||||
"integrity": "sha512-CaVEsBfgCXf7o0K8+POwoGCyas79FkNovyzzfkYn3pJ9D6H4HaGzpLf9DBVHPw7tHyPPSMzhNoFkiytqDYQsrw==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"invariant": "^2.2.4"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"expo": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/expo-constants": {
|
||||
"version": "17.0.5",
|
||||
"resolved": "https://registry.npmjs.org/expo-constants/-/expo-constants-17.0.5.tgz",
|
||||
@ -8075,9 +8552,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/expo-file-system": {
|
||||
"version": "18.0.10",
|
||||
"resolved": "https://registry.npmjs.org/expo-file-system/-/expo-file-system-18.0.10.tgz",
|
||||
"integrity": "sha512-+GnxkI+J9tOzUQMx+uIOLBEBsO2meyoYHxd87m9oT9M//BpepYqI1AvYBH8YM4dgr9HaeaeLr7z5XFVqfL8tWg==",
|
||||
"version": "18.0.11",
|
||||
"resolved": "https://registry.npmjs.org/expo-file-system/-/expo-file-system-18.0.11.tgz",
|
||||
"integrity": "sha512-yDwYfEzWgPXsBZHJW2RJ8Q66ceiFN9Wa5D20pp3fjXVkzPBDwxnYwiPWk4pVmCa5g4X5KYMoMne1pUrsL4OEpg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"web-streams-polyfill": "^3.3.2"
|
||||
@ -8100,6 +8577,19 @@
|
||||
"react": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/expo-gl": {
|
||||
"version": "13.6.0",
|
||||
"resolved": "https://registry.npmjs.org/expo-gl/-/expo-gl-13.6.0.tgz",
|
||||
"integrity": "sha512-hhRC2ZTDpc2YoElojutJTOYQsjSxX68lgL+2TSgWRrrvUXFeua1Ohz5DL/0iNCeoabs1earf/4qhxIdozkrhMA==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"invariant": "^2.2.4"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"expo": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/expo-haptics": {
|
||||
"version": "14.0.1",
|
||||
"resolved": "https://registry.npmjs.org/expo-haptics/-/expo-haptics-14.0.1.tgz",
|
||||
@ -8109,6 +8599,27 @@
|
||||
"expo": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/expo-image-loader": {
|
||||
"version": "5.0.0",
|
||||
"resolved": "https://registry.npmjs.org/expo-image-loader/-/expo-image-loader-5.0.0.tgz",
|
||||
"integrity": "sha512-Eg+5FHtyzv3Jjw9dHwu2pWy4xjf8fu3V0Asyy42kO+t/FbvW/vjUixpTjPtgKQLQh+2/9Nk4JjFDV6FwCnF2ZA==",
|
||||
"license": "MIT",
|
||||
"peerDependencies": {
|
||||
"expo": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/expo-image-picker": {
|
||||
"version": "16.0.6",
|
||||
"resolved": "https://registry.npmjs.org/expo-image-picker/-/expo-image-picker-16.0.6.tgz",
|
||||
"integrity": "sha512-HN4xZirFjsFDIsWFb12AZh19fRzuvZjj2ll17cGr19VNRP06S/VPQU3Tdccn5vwUzQhOBlLu704CnNm278boiQ==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"expo-image-loader": "~5.0.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"expo": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/expo-keep-awake": {
|
||||
"version": "14.0.2",
|
||||
"resolved": "https://registry.npmjs.org/expo-keep-awake/-/expo-keep-awake-14.0.2.tgz",
|
||||
@ -9808,6 +10319,16 @@
|
||||
"node": ">=8"
|
||||
}
|
||||
},
|
||||
"node_modules/is-plain-obj": {
|
||||
"version": "2.1.0",
|
||||
"resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-2.1.0.tgz",
|
||||
"integrity": "sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"engines": {
|
||||
"node": ">=8"
|
||||
}
|
||||
},
|
||||
"node_modules/is-plain-object": {
|
||||
"version": "2.0.4",
|
||||
"resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
|
||||
@ -11123,6 +11644,12 @@
|
||||
"integrity": "sha512-bF7vcQxbODoGK1imE2P9GS9aw4zD0Sd+Hni68IMZLj7zRnquH7dXUmMw9hDI5S/Jzt7q+IyTXN0rSg2GI0IKhQ==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/jpeg-js": {
|
||||
"version": "0.4.4",
|
||||
"resolved": "https://registry.npmjs.org/jpeg-js/-/jpeg-js-0.4.4.tgz",
|
||||
"integrity": "sha512-WZzeDOEtTOBK4Mdsar0IqEU5sMr3vSV2RqkAIzUEV2BHnUfKGyswWFPFwK5EeDo93K3FohSHbLAjj0s1Wzd+dg==",
|
||||
"license": "BSD-3-Clause"
|
||||
},
|
||||
"node_modules/js-tokens": {
|
||||
"version": "4.0.0",
|
||||
"resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
|
||||
@ -11774,6 +12301,12 @@
|
||||
"node": ">=4"
|
||||
}
|
||||
},
|
||||
"node_modules/long": {
|
||||
"version": "4.0.0",
|
||||
"resolved": "https://registry.npmjs.org/long/-/long-4.0.0.tgz",
|
||||
"integrity": "sha512-XsP+KhQif4bjX1kbuSiySJFNAehNxgLb6hPRGJ9QsUr8ajHkuXGdrHmFUTUUXhDwVX2R5bY4JNZEwbUiMhV+MA==",
|
||||
"license": "Apache-2.0"
|
||||
},
|
||||
"node_modules/loose-envify": {
|
||||
"version": "1.4.0",
|
||||
"resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
|
||||
@ -11890,6 +12423,19 @@
|
||||
"integrity": "sha512-zYiwtZUcYyXKo/np96AGZAckk+FWWsUdJ3cHGGmld7+AhvcWmQyGCYUh1hc4Q/pkOhb65dQR/pqCyK0cOaHz4Q==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/merge-options": {
|
||||
"version": "3.0.4",
|
||||
"resolved": "https://registry.npmjs.org/merge-options/-/merge-options-3.0.4.tgz",
|
||||
"integrity": "sha512-2Sug1+knBjkaMsMgf1ctR1Ujx+Ayku4EdJN4Z+C2+JzoeF7A3OZ9KM2GY0CpQS51NR61LTurMJrRKPhSs3ZRTQ==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"is-plain-obj": "^2.1.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=10"
|
||||
}
|
||||
},
|
||||
"node_modules/merge-stream": {
|
||||
"version": "2.0.0",
|
||||
"resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
|
||||
@ -12096,6 +12642,68 @@
|
||||
"node": ">=18.18"
|
||||
}
|
||||
},
|
||||
"node_modules/metro-react-native-babel-preset": {
|
||||
"version": "0.77.0",
|
||||
"resolved": "https://registry.npmjs.org/metro-react-native-babel-preset/-/metro-react-native-babel-preset-0.77.0.tgz",
|
||||
"integrity": "sha512-HPPD+bTxADtoE4y/4t1txgTQ1LVR6imOBy7RMHUsqMVTbekoi8Ph5YI9vKX2VMPtVWeFt0w9YnCSLPa76GcXsA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@babel/core": "^7.20.0",
|
||||
"@babel/plugin-proposal-async-generator-functions": "^7.0.0",
|
||||
"@babel/plugin-proposal-class-properties": "^7.18.0",
|
||||
"@babel/plugin-proposal-export-default-from": "^7.0.0",
|
||||
"@babel/plugin-proposal-nullish-coalescing-operator": "^7.18.0",
|
||||
"@babel/plugin-proposal-numeric-separator": "^7.0.0",
|
||||
"@babel/plugin-proposal-object-rest-spread": "^7.20.0",
|
||||
"@babel/plugin-proposal-optional-catch-binding": "^7.0.0",
|
||||
"@babel/plugin-proposal-optional-chaining": "^7.20.0",
|
||||
"@babel/plugin-syntax-dynamic-import": "^7.8.0",
|
||||
"@babel/plugin-syntax-export-default-from": "^7.0.0",
|
||||
"@babel/plugin-syntax-flow": "^7.18.0",
|
||||
"@babel/plugin-syntax-nullish-coalescing-operator": "^7.0.0",
|
||||
"@babel/plugin-syntax-optional-chaining": "^7.0.0",
|
||||
"@babel/plugin-transform-arrow-functions": "^7.0.0",
|
||||
"@babel/plugin-transform-async-to-generator": "^7.20.0",
|
||||
"@babel/plugin-transform-block-scoping": "^7.0.0",
|
||||
"@babel/plugin-transform-classes": "^7.0.0",
|
||||
"@babel/plugin-transform-computed-properties": "^7.0.0",
|
||||
"@babel/plugin-transform-destructuring": "^7.20.0",
|
||||
"@babel/plugin-transform-flow-strip-types": "^7.20.0",
|
||||
"@babel/plugin-transform-function-name": "^7.0.0",
|
||||
"@babel/plugin-transform-literals": "^7.0.0",
|
||||
"@babel/plugin-transform-modules-commonjs": "^7.0.0",
|
||||
"@babel/plugin-transform-named-capturing-groups-regex": "^7.0.0",
|
||||
"@babel/plugin-transform-parameters": "^7.0.0",
|
||||
"@babel/plugin-transform-react-display-name": "^7.0.0",
|
||||
"@babel/plugin-transform-react-jsx": "^7.0.0",
|
||||
"@babel/plugin-transform-react-jsx-self": "^7.0.0",
|
||||
"@babel/plugin-transform-react-jsx-source": "^7.0.0",
|
||||
"@babel/plugin-transform-runtime": "^7.0.0",
|
||||
"@babel/plugin-transform-shorthand-properties": "^7.0.0",
|
||||
"@babel/plugin-transform-spread": "^7.0.0",
|
||||
"@babel/plugin-transform-sticky-regex": "^7.0.0",
|
||||
"@babel/plugin-transform-typescript": "^7.5.0",
|
||||
"@babel/plugin-transform-unicode-regex": "^7.0.0",
|
||||
"@babel/template": "^7.0.0",
|
||||
"babel-plugin-transform-flow-enums": "^0.0.2",
|
||||
"react-refresh": "^0.4.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@babel/core": "*"
|
||||
}
|
||||
},
|
||||
"node_modules/metro-react-native-babel-preset/node_modules/react-refresh": {
|
||||
"version": "0.4.3",
|
||||
"resolved": "https://registry.npmjs.org/react-refresh/-/react-refresh-0.4.3.tgz",
|
||||
"integrity": "sha512-Hwln1VNuGl/6bVwnd0Xdn1e84gT/8T9aYNL+HAKDArLCS7LWjwr7StE30IEYbIkx0Vi3vs+coQxe+SQDbGbbpA==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=0.10.0"
|
||||
}
|
||||
},
|
||||
"node_modules/metro-resolver": {
|
||||
"version": "0.81.1",
|
||||
"resolved": "https://registry.npmjs.org/metro-resolver/-/metro-resolver-0.81.1.tgz",
|
||||
@ -13916,6 +14524,38 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/react-native-dotenv": {
|
||||
"version": "3.4.11",
|
||||
"resolved": "https://registry.npmjs.org/react-native-dotenv/-/react-native-dotenv-3.4.11.tgz",
|
||||
"integrity": "sha512-6vnIE+WHABSeHCaYP6l3O1BOEhWxKH6nHAdV7n/wKn/sciZ64zPPp2NUdEUf1m7g4uuzlLbjgr+6uDt89q2DOg==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"dotenv": "^16.4.5"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@babel/runtime": "^7.20.6"
|
||||
}
|
||||
},
|
||||
"node_modules/react-native-fs": {
|
||||
"version": "2.20.0",
|
||||
"resolved": "https://registry.npmjs.org/react-native-fs/-/react-native-fs-2.20.0.tgz",
|
||||
"integrity": "sha512-VkTBzs7fIDUiy/XajOSNk0XazFE9l+QlMAce7lGuebZcag5CnjszB+u4BdqzwaQOdcYb5wsJIsqq4kxInIRpJQ==",
|
||||
"license": "MIT",
|
||||
"peer": true,
|
||||
"dependencies": {
|
||||
"base-64": "^0.1.0",
|
||||
"utf8": "^3.0.0"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"react-native": "*",
|
||||
"react-native-windows": "*"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"react-native-windows": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/react-native-gesture-handler": {
|
||||
"version": "2.20.2",
|
||||
"resolved": "https://registry.npmjs.org/react-native-gesture-handler/-/react-native-gesture-handler-2.20.2.tgz",
|
||||
@ -14667,6 +15307,12 @@
|
||||
"url": "https://opencollective.com/webpack"
|
||||
}
|
||||
},
|
||||
"node_modules/seedrandom": {
|
||||
"version": "3.0.5",
|
||||
"resolved": "https://registry.npmjs.org/seedrandom/-/seedrandom-3.0.5.tgz",
|
||||
"integrity": "sha512-8OwmbklUNzwezjGInmZ+2clQmExQPvomqjL7LFqOYqtmuxRgQYqOD3mHaU+MvZn5FLUeVxVfQjwLZW/n/JFuqg==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/selfsigned": {
|
||||
"version": "2.4.1",
|
||||
"resolved": "https://registry.npmjs.org/selfsigned/-/selfsigned-2.4.1.tgz",
|
||||
@ -15362,6 +16008,15 @@
|
||||
"node": ">=4"
|
||||
}
|
||||
},
|
||||
"node_modules/string_decoder": {
|
||||
"version": "1.3.0",
|
||||
"resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.3.0.tgz",
|
||||
"integrity": "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"safe-buffer": "~5.2.0"
|
||||
}
|
||||
},
|
||||
"node_modules/string-length": {
|
||||
"version": "4.0.2",
|
||||
"resolved": "https://registry.npmjs.org/string-length/-/string-length-4.0.2.tgz",
|
||||
@ -16541,6 +17196,13 @@
|
||||
"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
|
||||
}
|
||||
},
|
||||
"node_modules/utf8": {
|
||||
"version": "3.0.0",
|
||||
"resolved": "https://registry.npmjs.org/utf8/-/utf8-3.0.0.tgz",
|
||||
"integrity": "sha512-E8VjFIQ/TyQgp+TZfS6l8yp/xWppSAHzidGiRrqe4bK4XP9pTRyKFgGJpO3SN7zdX4DeomTrwaseCHovfpFcqQ==",
|
||||
"license": "MIT",
|
||||
"peer": true
|
||||
},
|
||||
"node_modules/util": {
|
||||
"version": "0.12.5",
|
||||
"resolved": "https://registry.npmjs.org/util/-/util-0.12.5.tgz",
|
||||
|
@ -18,11 +18,15 @@
|
||||
"@expo/vector-icons": "^14.0.2",
|
||||
"@react-navigation/bottom-tabs": "^7.2.0",
|
||||
"@react-navigation/native": "^7.0.14",
|
||||
"@tensorflow/tfjs": "^4.22.0",
|
||||
"@tensorflow/tfjs-react-native": "^1.0.0",
|
||||
"expo": "~52.0.31",
|
||||
"expo-blur": "~14.0.3",
|
||||
"expo-constants": "~17.0.5",
|
||||
"expo-file-system": "~18.0.11",
|
||||
"expo-font": "~13.0.3",
|
||||
"expo-haptics": "~14.0.1",
|
||||
"expo-image-picker": "~16.0.6",
|
||||
"expo-linking": "~7.0.5",
|
||||
"expo-router": "~4.0.17",
|
||||
"expo-splash-screen": "~0.29.21",
|
||||
@ -30,16 +34,17 @@
|
||||
"expo-symbols": "~0.2.2",
|
||||
"expo-system-ui": "~4.0.8",
|
||||
"expo-web-browser": "~14.0.2",
|
||||
"metro-react-native-babel-preset": "^0.77.0",
|
||||
"react": "18.3.1",
|
||||
"react-dom": "18.3.1",
|
||||
"react-native": "0.76.7",
|
||||
"react-native-dotenv": "^3.4.11",
|
||||
"react-native-gesture-handler": "~2.20.2",
|
||||
"react-native-reanimated": "~3.16.1",
|
||||
"react-native-safe-area-context": "4.12.0",
|
||||
"react-native-screens": "~4.4.0",
|
||||
"react-native-web": "~0.19.13",
|
||||
"react-native-webview": "13.12.5",
|
||||
"expo-image-picker": "~16.0.6"
|
||||
"react-native-webview": "13.12.5"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@babel/core": "^7.25.2",
|
||||
|
I think it would be good to make this an
env
variable, like the API key.That way we can change the model on-the-fly easier
You can resolve this comment when done
I think it would be good to make this an
env
variable, like the API key.That way we can change the model on-the-fly easier
You can resolve this comment when done
Now that we have environment variables using
dotenv
, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion.env.example
This file will might look similar toThe purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
.env
. Essentially we instruct the developer to copy the.env.example
with the new name.env
(cp .env.example .env
) and to paste their api key.You can resolve this comment when done
Now that we have environment variables using
dotenv
, developers need to be aware of this so they can build and run the app locally. Since you may not have done this before, here is my suggestion.env.example
This file will might look similar toThe purpose here, is we force the developer to enter their secret key which is not committed, but also make it easy to uncomment/switch models.
.env
. Essentially we instruct the developer to copy the.env.example
with the new name.env
(cp .env.example .env
) and to paste their api key.You can resolve this comment when done
Do you mean the link?
Do you mean the link?