remove unneeded escapes

Author: adhami3310

docs/advanced_onboarding/how-reflex-works.md

@@ -99,13 +99,13 @@ Under the hood, these components compile down to React components. For example,
 
 ```jsx
 <HStack>
-    <Link href=\{GithubState.url}>
-        <Avatar src=\{GithubState.profile_image}/>
+    <Link href={GithubState.url}>
+        <Avatar src={GithubState.profile_image}/>
     </Link>
     <Input
         placeholder="Your Github username"
         // This would actually be a websocket call to the backend.
-        onBlur=\{GithubState.set_profile}
+        onBlur={GithubState.set_profile}
     >
 </HStack>
 ```
@@ -140,7 +140,7 @@ class GithubState(rx.State):
     def set_profile(self, username: str):
         if username == "":
             return
-        github_data = requests.get(f"https://api.github.com/users/\{username}").json()
+        github_data = requests.get(f"https://api.github.com/users/{username}").json()
         self.url = github_data["url"]
         self.profile_image = github_data["avatar_url"]
 ```
@@ -216,7 +216,7 @@ Once we have the user's state, the next step is to run the event handler with th
 def set_profile(self, username: str):
     if username == "":
         return
-    github_data = requests.get(f"https://api.github.com/users/\{username}").json()
+    github_data = requests.get(f"https://api.github.com/users/{username}").json()
     self.url = github_data["url"]
     self.profile_image = github_data["avatar_url"]
 ```

docs/api-reference/var_system.md

@@ -30,7 +30,7 @@ If the type is known, it can be any of the following:
 - `BooleanVar` represents a boolean expression. For example: `false`, `3 > 2`.
 - `StringVar` represents an expression that evaluates to a string. For example: `'hello'`, `(2).toString()`.
 - `ArrayVar` represents an expression that evaluates to an array object. For example: `[1, 2, 3]`, `'words'.split()`.
-- `ObjectVar` represents an expression that evaluates to an object. For example: `\{a: 2, b: 3}`, `\{deeply: \{nested: \{value: false}}}`.
+- `ObjectVar` represents an expression that evaluates to an object. For example: `{a: 2, b: 3}`, `{deeply: {nested: {value: false}}}`.
 - `NoneVar` represent null values. These can be either `undefined` or `null`.
 
 ## Creating Vars
@@ -67,7 +67,7 @@ from reflex.vars import var_operation, var_operation_return, ArrayVar, NumberVar
 @var_operation
 def multiply_array_values(a: ArrayVar):
     return var_operation_return(
-        js_expression=f"\{a}.reduce((p, c) => p * c, 1)",
+        js_expression=f"{a}.reduce((p, c) => p * c, 1)",
         var_type=int,
     )
 

docs/app/templates/llamaindex-app.md

@@ -39,8 +39,8 @@ input_payload = {
 deployment_name = os.environ.get("DEPLOYMENT_NAME", "MyDeployment")
 apiserver_url = os.environ.get("APISERVER_URL", "http://localhost:4501")
 response = await client.post(
-    f"\{apiserver_url}/deployments/\{deployment_name}/tasks/create",
-    json=\{"input": json.dumps(input_payload)},
+    f"{apiserver_url}/deployments/{deployment_name}/tasks/create",
+    json={"input": json.dumps(input_payload)},
     timeout=60,
 )
 answer = response.text

docs/database/queries.md

@@ -173,16 +173,14 @@ import reflex as rx
 
 
 class State(rx.State):
-
     @rx.event
     def insert_user_raw(self, username, email):
         with rx.session() as session:
             session.execute(
                 sqlalchemy.text(
-                    "INSERT INTO user (username, email) "
-                    "VALUES (:username, :email)"
+                    "INSERT INTO user (username, email) VALUES (:username, :email)"
                 ),
-                \{"username": username, "email": email},
+                {"username": username, "email": email},
             )
             session.commit()
 

docs/database/relationships.md

@@ -138,7 +138,7 @@ chain loaded from the `Post.flags` relationship.
 ### Specifying the Loading Mechanism on the Relationship
 
 Alternatively, the loading mechanism can be specified on the relationship by
-passing `sa_relationship_kwargs=\{"lazy": method}` to `sqlmodel.Relationship`,
+passing `sa_relationship_kwargs={"lazy": method}` to `sqlmodel.Relationship`,
 which will use the given loading mechanism in all queries by default.
 
 ```python
@@ -153,10 +153,10 @@ class Post(rx.Model, table=True):
     ...
     user: Optional["User"] = sqlmodel.Relationship(
         back_populates="posts",
-        sa_relationship_kwargs=\{"lazy": "selectin"},
+        sa_relationship_kwargs={"lazy": "selectin"},
     )
     flags: Optional[List["Flag"]] = sqlmodel.Relationship(
         back_populates="post",
-        sa_relationship_kwargs=\{"lazy": "selectin"},
+        sa_relationship_kwargs={"lazy": "selectin"},
     )
 ```

docs/enterprise/ag_grid/index.md

@@ -45,9 +45,9 @@ The format of the data passed to the `row_data` prop is a list of dictionaries.
 
 ```python
 [
-   \{"direction": "N", "strength": "0-1", "frequency": 0.5\},
-   \{"direction": "NNE", "strength": "0-1", "frequency": 0.6\},
-   \{"direction": "NE", "strength": "0-1", "frequency": 0.5\},
+    {"direction": "N", "strength": "0-1", "frequency": 0.5},
+    {"direction": "NNE", "strength": "0-1", "frequency": 0.6},
+    {"direction": "NE", "strength": "0-1", "frequency": 0.5},
 ]
 ```
 
@@ -257,6 +257,7 @@ import reflex as rx
 import reflex_enterprise as rxe
 import pandas as pd
 
+
 class AGGridEditingState(rx.State):
     data: list[dict] = []
     _data_df: pd.DataFrame
@@ -270,15 +271,30 @@ class AGGridEditingState(rx.State):
     def cell_value_changed(self, row, col_field, new_value):
         self._data_df.at[row, col_field] = new_value
         self.data = self._data_df.to_dict("records")
-        yield rx.toast(f"Cell value changed, Row: {row}, Column: {col_field}, New Value: {new_value}")
+        yield rx.toast(
+            f"Cell value changed, Row: {row}, Column: {col_field}, New Value: {new_value}"
+        )
 
 
 column_defs = [
-    \{"field": "country"\},
-    \{"field": "pop", "headerName": "Population", "editable": True, "cellEditor": rxe.ag_grid.editors.number\},
-    \{"field": "continent", "editable": True, "cellEditor": rxe.ag_grid.editors.select, "cellEditorParams": \{"values": ['Asia', 'Europe', 'Africa', 'Americas', 'Oceania']\}\},
+    {"field": "country"},
+    {
+        "field": "pop",
+        "headerName": "Population",
+        "editable": True,
+        "cellEditor": rxe.ag_grid.editors.number,
+    },
+    {
+        "field": "continent",
+        "editable": True,
+        "cellEditor": rxe.ag_grid.editors.select,
+        "cellEditorParams": {
+            "values": ["Asia", "Europe", "Africa", "Americas", "Oceania"]
+        },
+    },
 ]
 
+
 def ag_grid_simple_editing():
     return rxe.ag_grid(
         id="ag_grid_basic_editing",
@@ -336,6 +352,7 @@ import reflex as rx
 import reflex_enterprise as rxe
 import pandas as pd
 
+
 class AGGridState2(rx.State):
     data: list[dict] = []
 
@@ -344,12 +361,14 @@ class AGGridState2(rx.State):
         _df = pd.read_csv("data/gapminder2007.csv")
         self.data = _df.to_dict("records")
 
+
 column_defs = [
-    \{"field": "country"\},
-    \{"field": "pop", "headerName": "Population"\},
-    \{"field": "continent"\},
+    {"field": "country"},
+    {"field": "pop", "headerName": "Population"},
+    {"field": "continent"},
 ]
 
+
 def ag_grid_state_2():
     return rxe.ag_grid(
         id="ag_grid_state_2",
@@ -370,8 +389,10 @@ import reflex as rx
 import reflex_enterprise as rxe
 import pandas as pd
 
+
 class AgGridState(rx.State):
     """The app state."""
+
     all_columns: list = []
 
     two_columns: list = []
@@ -381,15 +402,15 @@ class AgGridState(rx.State):
     @rx.event
     def init_columns(self):
         self.all_columns = [
-            \{"field": "country"\},
-            \{"field": "pop"\},
-            \{"field": "continent"\},
-            \{"field": "lifeExp"\},
-            \{"field": "gdpPercap"\},
+            {"field": "country"},
+            {"field": "pop"},
+            {"field": "continent"},
+            {"field": "lifeExp"},
+            {"field": "gdpPercap"},
         ]
         self.two_columns = [
-            \{"field": "country"\},
-            \{"field": "pop"\},
+            {"field": "country"},
+            {"field": "pop"},
         ]
         self.column_defs = self.all_columns
 
@@ -436,14 +457,14 @@ import reflex_enterprise as rxe
 import pandas as pd
 from sqlmodel import select
 
+
 class Country(rx.Model, table=True):
     country: str
     population: int
     continent: str
 
 
 class AGGridDatabaseState(rx.State):
-
     countries: list[Country]
 
     # Insert data from a csv loaded dataframe to the database (Do this on the page load)
@@ -453,9 +474,9 @@ class AGGridDatabaseState(rx.State):
         with rx.session() as session:
             for _, row in data.iterrows():
                 db_record = Country(
-                    country=row['country'],
-                    population=row['pop'],
-                    continent=row['continent'],
+                    country=row["country"],
+                    population=row["pop"],
+                    continent=row["continent"],
                 )
                 session.add(db_record)
             session.commit()
@@ -476,15 +497,30 @@ class AGGridDatabaseState(rx.State):
             country = Country(**self.countries[row])
             session.merge(country)
             session.commit()
-        yield rx.toast(f"Cell value changed, Row: \{row}, Column: \{col_field}, New Value: \{new_value}")
+        yield rx.toast(
+            f"Cell value changed, Row: {row}, Column: {col_field}, New Value: {new_value}"
+        )
 
 
 column_defs = [
-    \{"field": "country"\},
-    \{"field": "population", "headerName": "Population", "editable": True, "cellEditor": rxe.ag_grid.editors.number\},
-    \{"field": "continent", "editable": True, "cellEditor": rxe.ag_grid.editors.select, "cellEditorParams": \{"values": ['Asia', 'Europe', 'Africa', 'Americas', 'Oceania']\}\},
+    {"field": "country"},
+    {
+        "field": "population",
+        "headerName": "Population",
+        "editable": True,
+        "cellEditor": rxe.ag_grid.editors.number,
+    },
+    {
+        "field": "continent",
+        "editable": True,
+        "cellEditor": rxe.ag_grid.editors.select,
+        "cellEditorParams": {
+            "values": ["Asia", "Europe", "Africa", "Americas", "Oceania"]
+        },
+    },
 ]
 
+
 def index():
     return rxe.ag_grid(
         id="ag_grid_basic_editing",
@@ -495,6 +531,7 @@ def index():
         height="40vh",
     )
 
+
 # Add state and page to the app.
 app = rx.App()
 app.add_page(index, on_load=AGGridDatabaseState.insert_dataframe_to_db)
@@ -657,9 +694,9 @@ df = pd.read_csv(
 )
 
 column_defs = [
-    \{"field": "country", "checkboxSelection": True\},
-    \{"field": "pop"\},
-    \{"field": "continent"\},
+    {"field": "country", "checkboxSelection": True},
+    {"field": "pop"},
+    {"field": "continent"},
 ]
 
 def ag_grid_api_argument():

docs/getting_started/chatapp_tutorial.md

@@ -112,7 +112,7 @@ uv run reflex run
 
 You should see your app running at [http://localhost:3000](http://localhost:3000).
 
-Reflex also starts the backend server which handles all the state management and communication with the frontend. You can test the backend server is running by navigating to [http://localhost:8000/ping]({"http://localhost:8000/ping"}).
+Reflex also starts the backend server which handles all the state management and communication with the frontend. You can test the backend server is running by navigating to [http://localhost:8000/ping](http://localhost:8000/ping).
 
 Now that we have our project set up, in the next section we will start building our app!
 
@@ -627,16 +627,15 @@ import os
 
 from openai import AsyncOpenAI
 
+
 @rx.event
 async def answer(self):
     # Our chatbot has some brains now!
     client = AsyncOpenAI(api_key=os.environ["OPENAI_API_KEY"])
 
     session = await client.chat.completions.create(
         model="gpt-4o-mini",
-        messages=[
-            \{"role": "user", "content": self.question}
-        ],
+        messages=[{"role": "user", "content": self.question}],
         stop=None,
         temperature=0.7,
         stream=True,
@@ -736,6 +735,7 @@ import os
 from openai import AsyncOpenAI
 import reflex as rx
 
+
 class State(rx.State):
     question: str
     chat_history: list[tuple[str, str]] = []
@@ -746,9 +746,7 @@ class State(rx.State):
         # Start streaming completion from OpenAI
         session = await client.chat.completions.create(
             model="gpt-4o-mini",
-            messages=[
-                \{"role": "user", "content": self.question}
-            ],
+            messages=[{"role": "user", "content": self.question}],
             temperature=0.7,
             stream=True,
         )