Update README.md

README.md

@@ -1,201 +1,523 @@
 ---
+language:
+- en
+license: apache-2.0
 library_name: transformers
-tags: []
+tags:
+- planning
+- code
+- policy control
+- parsing
+- python
+- java
+- cpp
+- sql
+- function calling
+- unit tests
+- causalLM
+- codeLLAMA 
+- instruction_tuned
+- basemodel
+- pytorch
+- docstring
+- documentation
+- text-generation-inference
+metrics:
+- accuracy
+pipeline_tag: text-generation
+widget:
+- text: '<function_code>def _plot_bounding_polygon(polygons_coordinates, output_html_path=bounding_polygon_map.html):map_center = [sum([coord[0]for polygon_coords in polygons_coordinatesfor coord in polygon_coords])/ sum([len(polygon_coords) for polygon_coords in polygons_coordinates]),sum([coord[1]for polygon_coords in polygons_coordinatesfor coord in polygon_coords])/ sum([len(polygon_coords) for polygon_coords in polygons_coordinates]),]my_map = folium.Map(location=map_center, zoom_start=12)for polygon_coords in polygons_coordinates:folium.Polygon(locations=polygon_coords,color=blue,fill=True,fill_color=blue,fill_opacity=0.2,).add_to(my_map)marker_cluster = MarkerCluster().add_to(my_map)for polygon_coords in polygons_coordinates:for coord in polygon_coords:folium.Marker(location=[coord[0], coord[1]], popup=fCoordinates: {coord}).add_to(marker_cluster)draw = Draw(export=True)draw.add_to(my_map)my_map.save(output_html_path)return output_html_path</function_code><question>Document the python code above giving function description ,parameters and return type and example how to call the function</question><doc>'
+  example_title: example
 ---
+# pip-library-etl-1.3b
 
-# Model Card for Model ID
+[pipableAi](https://www.linkedin.com/company/pipable.ai/about/)
 
-<!-- Provide a quick summary of what the model is/does. -->
+[colab_notebook](https://colab.research.google.com/drive/17PyMU_3QN9LROy7x-jmaema0cuLRzBvc?usp=sharing)
 
+[pip library_etl](https://github.com/PipableAI/pip-library-etl.git)
 
+[linkedin_post](https://www.linkedin.com/posts/pipable%2Eai_github-pipableaipip-library-etl-this-activity-7179111129678327809-Pgxy?utm_source=share&utm_medium=member_desktop)
 
-## Model Details
+## What have we built?
 
-### Model Description
+A 1.3 bn code documentation model that outperforms most models on documenting codes and making your in-house libs ready for LLM and RAG pipelines.
+We have also open sourced a [pip library_etl](https://github.com/PipableAI/pip-library-etl.git) for the same, together the lib and model can turn your codebase to functional parse tree ready to be consumed by LLMs to execute complex tasks.
+This model is also capable of generating SQL queries with accuracies on par with those of [pip-sql-1.3b](https://huggingface.co/PipableAI/pip-sql-1.3b), with additional capabilities of providing extra examples, instructions ,and column descriptions as context.
+This is a further trained version of pip-sql-1.3b and performance comparable to GPT.
 
-<!-- Provide a longer summary of what this model is. -->
 
-This is the model card of a 🤗 transformers model that has been pushed on the Hub. This model card has been automatically generated.
+## How we built it?
 
-- **Developed by:** [More Information Needed]
-- **Funded by [optional]:** [More Information Needed]
-- **Shared by [optional]:** [More Information Needed]
-- **Model type:** [More Information Needed]
-- **Language(s) (NLP):** [More Information Needed]
-- **License:** [More Information Needed]
-- **Finetuned from model [optional]:** [More Information Needed]
+We used softmax cross entropy and a modified form of policy grad along with Q loss, optimized in an EM set up.
+The performance for the metioned tasks are comparable to much bigger LLMs and GPT-3.5
 
-### Model Sources [optional]
+## License
 
-<!-- Provide the basic links for the model. -->
+The model is open source under apache 2.0. License
 
-- **Repository:** [More Information Needed]
-- **Paper [optional]:** [More Information Needed]
-- **Demo [optional]:** [More Information Needed]
-
-## Uses
-
-<!-- Address questions around how the model is intended to be used, including the foreseeable users of the model and those affected by the model. -->
-
-### Direct Use
-
-<!-- This section is for the model use without fine-tuning or plugging into a larger ecosystem/app. -->
-
-[More Information Needed]
-
-### Downstream Use [optional]
-
-<!-- This section is for the model use when fine-tuned for a task, or when plugged into a larger ecosystem/app -->
-
-[More Information Needed]
-
-### Out-of-Scope Use
-
-<!-- This section addresses misuse, malicious use, and uses that the model will not work well for. -->
-
-[More Information Needed]
-
-## Bias, Risks, and Limitations
-
-<!-- This section is meant to convey both technical and sociotechnical limitations. -->
-
-[More Information Needed]
-
-### Recommendations
-
-<!-- This section is meant to convey recommendations with respect to the bias, risk, and technical limitations. -->
-
-Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. More information needed for further recommendations.
-
-## How to Get Started with the Model
-
-Use the code below to get started with the model.
-
-[More Information Needed]
-
-## Training Details
-
-### Training Data
-
-<!-- This should link to a Dataset Card, perhaps with a short stub of information on what the training data is all about as well as documentation related to data pre-processing or additional filtering. -->
-
-[More Information Needed]
-
-### Training Procedure 
-
-<!-- This relates heavily to the Technical Specifications. Content here should link to that section when it is relevant to the training procedure. -->
-
-#### Preprocessing [optional]
-
-[More Information Needed]
-
-
-#### Training Hyperparameters
-
-- **Training regime:** [More Information Needed] <!--fp32, fp16 mixed precision, bf16 mixed precision, bf16 non-mixed precision, fp16 non-mixed precision, fp8 mixed precision -->
-
-#### Speeds, Sizes, Times [optional]
-
-<!-- This section provides information about throughput, start/end time, checkpoint size if relevant, etc. -->
-
-[More Information Needed]
-
-## Evaluation
-
-<!-- This section describes the evaluation protocols and provides the results. -->
-
-### Testing Data, Factors & Metrics
-
-#### Testing Data
-
-<!-- This should link to a Dataset Card if possible. -->
-
-[More Information Needed]
-
-#### Factors
-
-<!-- These are the things the evaluation is disaggregating by, e.g., subpopulations or domains. -->
-
-[More Information Needed]
-
-#### Metrics
-
-<!-- These are the evaluation metrics being used, ideally with a description of why. -->
-
-[More Information Needed]
-
-### Results
-
-[More Information Needed]
-
-#### Summary
-
-
-
-## Model Examination [optional]
-
-<!-- Relevant interpretability work for the model goes here -->
-
-[More Information Needed]
-
-## Environmental Impact
-
-<!-- Total emissions (in grams of CO2eq) and additional considerations, such as electricity usage, go here. Edit the suggested text below accordingly -->
-
-Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700).
-
-- **Hardware Type:** [More Information Needed]
-- **Hours used:** [More Information Needed]
-- **Cloud Provider:** [More Information Needed]
-- **Compute Region:** [More Information Needed]
-- **Carbon Emitted:** [More Information Needed]
-
-## Technical Specifications [optional]
-
-### Model Architecture and Objective
-
-[More Information Needed]
-
-### Compute Infrastructure
-
-[More Information Needed]
-
-#### Hardware
-
-[More Information Needed]
-
-#### Software
-
-[More Information Needed]
-
-## Citation [optional]
-
-<!-- If there is a paper or blog post introducing the model, the APA and Bibtex information for that should go in this section. -->
-
-**BibTeX:**
-
-[More Information Needed]
-
-**APA:**
-
-[More Information Needed]
-
-## Glossary [optional]
-
-<!-- If relevant, include terms and calculations in this section that can help readers understand the model or model card. -->
-
-[More Information Needed]
-
-## More Information [optional]
-
-[More Information Needed]
-
-## Model Card Authors [optional]
-
-[More Information Needed]
-
-## Model Card Contact
-
-[More Information Needed]
+## Usage
 
+### NOTE:
 
+
+If you wish to try this model without utilizing your GPU, we have hosted the model on our end. To execute the library using the hosted playground model, initialize the generator as shown below:
+
+```python
+from pip_library_etl import PipEtl
+
+generator = PipEtl(device="cloud")
+```
+
+We have hosted the model at https://playground.pipable.ai/infer. Hence, one can also make a POST request to this endpoint with the following payload:
+
+```json
+{
+    "model_name": "PipableAI/pip-library-etl-1.3b",
+    "prompt": "prompt",
+    "max_new_tokens": "400"
+}
+```
+
+```bash
+curl -X 'POST' \
+  'https://playground.pipable.ai/infer' \
+  -H 'accept: application/json' \
+  -H 'Content-Type: application/x-www-form-urlencoded' \
+  -d 'model_name=PipableAI%2Fpip-library-etl-1.3b&prompt="YOUR PROMPT"&max_new_tokens=400'
+```
+
+Alternatively, you can directly access UI endpoint at https://playground.pipable.ai/docs#/default/infer_infer_post.
+
+### Library use
+
+For directly using the capabilities of model without putting extra efforts on schems and prompts try to use [pip library_etl](https://github.com/PipableAI/pip-library-etl.git).
+
+Here's a brief overview of what can be achieved using the PipEtl library:
+
+- `Function Call Generation` : The generate_function_call method facilitates the generation of Python function calls based on provided questions and either docstrings or undocumented code. This feature can be useful for generating example function calls or for prototyping code snippets.
+- `Automated Documentation Generation` : With the generate_docstring method, users can automatically generate comprehensive docstrings for Python functions. This feature aids in maintaining well-documented codebases and adhering to best practices.
+- `Module Documentation` : The generate_module_docstrings method allows for generating documentation for all methods and functions within a given module or package. This capability streamlines the documentation process, especially for large codebases with numerous functions.
+- `SQL Query Generation` : Users can leverage the generate_sql method to automatically generate SQL queries based on provided schemas and questions. This functionality simplifies the process of creating SQL queries, particularly for data-related tasks.
+
+For detailed usage refer to the [colab_notebook](https://colab.research.google.com/drive/17PyMU_3QN9LROy7x-jmaema0cuLRzBvc?usp=sharing)
+
+
+### Installation
+
+```bash
+pip install transformers
+```
+
+### Prompt
+```python
+prompt = f"""<example_response>{--question , --query}</example_response><function_code>{code}</function_code>
+<question>Give one line description of the python code above in natural language.</question>
+<doc>"""
+
+prompt = f"""<example_response>{example of some  --question: , --query}</example_response><schema>{schema with cols described}</schema>
+<question>Write a sql query to ....</question>
+<sql>"""
+```
+
+### PyTorch
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+device = "cuda"
+model = AutoModelForCausalLM.from_pretrained("PipableAI/pip-library-etl-1.3b").to(device)
+tokenizer = AutoTokenizer.from_pretrained("PipableAI/pip-library-etl-1.3b")
+prompt = f"""
+<example_response>
+--code:def divide_by_two(x: float) -> float: return x / 2
+--question:Document the python code above giving function description ,parameters and return type and example on how to call the function
+--doc:
+Description: This function divides a given number by 2.
+Parameters:
+- x (float): The input value to be divided by 2.
+Returns:
+- float: The result of x divided by 2.
+Example:
+divide_by_two(1.0)
+</example_response>
+<function_code>
+def download_file(shared_url, destination):
+    try:
+        if not shared_url.startswith("https://drive.google.com"):
+            raise ValueError("Please provde a valid google drive link.")
+        file_id = shared_url.split("/d/")[1]
+        file_id = file_id.split("/")[0]
+        url = f"https://drive.google.com/uc?id={file_id}"
+        gdown.download(url, destination, quiet=False)
+    except Exception as e:
+        print(f"Error downloading file from Google Drive as {e}")
+        raise e
+</function_code>
+<instructions> 
+1. In the examples while calling function use the name mentioned after `def ` in the above function_code.
+2. In the generated docs use valid python type hints as per PEP 484.
+</instructions>
+<question>Document the python code above giving function description ,parameters and return type and example how to call the function.</question>
+<doc>
+"""
+inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
+outputs = model.generate(**inputs, max_new_tokens=450)
+doc = (
+    tokenizer.decode(outputs[0], skip_special_tokens=True)
+    .split("<doc>")[-1]
+    .split("</doc>")[0]
+)
+doc = (
+    doc.replace("<p>", "")
+    .replace("</p>", "")
+    .replace("<function_description>", "")
+    .replace("</function_description>", "")
+)
+print(doc)
+```
+
+
+
+## Examples
+
+### 1. Code Documentation
+### prompt
+```python
+prompt ='''<example_response>
+--code:def divide_by_two(x: float) -> float: return x / 2
+--question:Document the python code above giving function description ,parameters and return type and example on how to call the function
+--doc:
+Description: This function divides a given number by 2.
+Parameters:
+- x (float): The input value to be divided by 2.
+Returns:
+- float: The result of x divided by 2.
+Example:
+divide_by_two(1.0)
+</example_response>
+<function_code>def _plot_bounding_polygon(
+    polygons_coordinates, output_html_path="bounding_polygon_map.html"
+):
+    # Create a Folium map centered at the average coordinates of all bounding boxes
+    map_center = [
+        sum(
+            [
+                coord[0]
+                for polygon_coords in polygons_coordinates
+                for coord in polygon_coords
+            ]
+        )
+        / sum([len(polygon_coords) for polygon_coords in polygons_coordinates]),
+        sum(
+            [
+                coord[1]
+                for polygon_coords in polygons_coordinates
+                for coord in polygon_coords
+            ]
+        )
+        / sum([len(polygon_coords) for polygon_coords in polygons_coordinates]),
+    ]
+
+    my_map = folium.Map(location=map_center, zoom_start=12)
+
+    # Add each bounding polygon to the map
+    for polygon_coords in polygons_coordinates:
+        folium.Polygon(
+            locations=polygon_coords,
+            color="blue",
+            fill=True,
+            fill_color="blue",
+            fill_opacity=0.2,
+        ).add_to(my_map)
+
+    # Add bounding boxes as markers to the map
+    marker_cluster = MarkerCluster().add_to(my_map)
+
+    for polygon_coords in polygons_coordinates:
+        for coord in polygon_coords:
+            folium.Marker(
+                location=[coord[0], coord[1]], popup=f"Coordinates: {coord}"
+            ).add_to(marker_cluster)
+
+    # Add draw control to allow users to draw additional polygons
+    draw = Draw(export=True)
+    draw.add_to(my_map)
+
+    # Save the map as an HTML file
+    my_map.save(output_html_path)
+
+    return output_html_path
+    </function_code>
+    <instructions> 
+    1. In the examples while calling function use the name mentioned after `def ` in the above function_code.
+    2. In the generated docs use valid python type hints as per PEP 484.
+    </instructions>
+    <question>Document the python code above giving function description ,parameters and return type and example how to call the function</question><doc>'''
+```
+
+### Response
+```txt
+ Description:This function generates a map of the bounding polygons and saves it as an HTML file.
+    Parameters:
+    - polygons_coordinates (list of lists of tuples): A list of lists of tuples representing the coordinates of the polygons. Each polygon is a list of coordinates.
+    - output_html_path (str, optional): The path where the HTML file should be saved. Defaults to "bounding_polygon_map.html".
+    Returns:
+    - str: The path to the saved HTML file.
+    Example:
+    To call the function, use the following code:
+    plot_bounding_polygon([[(0, 0), (1, 0), (1, 1), (0, 1)], [(2, 2), (3, 2), (3, 3), (2, 3)]], "my_map.html").
+```
+
+
+### 2. SQL Generation
+### prompt
+```python
+prompt = """Generate a simple SQL query from the schema mentioned for the following question.
+<schema>
+CREATE TABLE department (
+  Department_ID number,         -- Unique identifier for the department
+  Name text,                     -- Name of the department
+  Creation text,                 -- Date of creation or establishment
+  Ranking number,                -- Ranking of the department
+  Budget_in_Billions number,     -- Budget of the department in billions
+  Num_Employees number          -- Number of employees in the department
+);
+
+CREATE TABLE head (
+  head_ID number,                -- Unique identifier for the head
+  name text,                     -- Name of the head
+  born_state text,               -- State where the head was born
+  age number                     -- Age of the head
+);
+
+CREATE TABLE management (
+  department_ID number,          -- Foreign key referencing Department_ID in department table
+  head_ID number,                -- Foreign key referencing head_ID in head table
+  temporary_acting text          -- Indicates if the head is temporarily acting
+);
+</schema>
+<question>What are the names of the heads who are born outside the California state?</question>
+<sql>
+"""
+```
+
+### response
+```sql
+SELECT head.name FROM head WHERE head.born_state <> 'California';
+```
+
+### 3. Performance Schema Monitoring
+### prompt
+```python
+prompt = """Generate the SQL query for SkySQL performance schema for the following question.
+<example>
+--question: What are the top 10 most frequently used queries/statements?
+--sql: SELECT DIGEST_TEXT, COUNT(*) as frequency FROM performance_schema.events_statements_summary_by_digest GROUP BY DIGEST_TEXT ORDER BY frequency DESC LIMIT 10;
+</example>
+<schema>
+CREATE TABLE `accounts` (`USER` char(128)  DEFAULT NULL -- 'The connection''s client user name for the connection, or NULL if an internal thread.',
+  `HOST` char(255)  DEFAULT NULL -- 'The connection client''s host name, or NULL if an internal thread.',
+  `CURRENT_CONNECTIONS` bigint(20) NOT NULL -- 'Current connections for the account.',\n
+  `TOTAL_CONNECTIONS` bigint(20) NOT NULL -- 'Total connections for the account.'
+) ;
+</schema>
+<question>
+Tell me the number of active connections each user has.
+</question>
+<sql>
+"""
+```
+### response
+```sql
+SELECT USER, CURRENT_CONNECTIONS FROM accounts;
+```
+
+### prompt
+```python
+prompt = """Generate the SQL query for SkySQL performance schema for the following question.
+<example>
+--question: What are the top 10 most frequently used queries/statements?
+--sql: SELECT DIGEST_TEXT, COUNT(*) as frequency FROM performance_schema.events_statements_summary_by_digest GROUP BY DIGEST_TEXT ORDER BY frequency DESC LIMIT 10;
+</example>
+<schema>
+CREATE TABLE `file_summary_by_instance` (
+    `FILE_NAME` varchar(512) NOT NULL -- 'File name.',
+    `EVENT_NAME` varchar(128) NOT NULL -- 'Event name.',
+    `OBJECT_INSTANCE_BEGIN` bigint(20) unsigned NOT NULL -- 'Address in memory. Together with FILE_NAME and EVENT_NAME uniquely identifies a row.',
+    `COUNT_STAR` bigint(20) unsigned NOT NULL -- 'Number of summarized events',
+    `SUM_TIMER_WAIT` bigint(20) unsigned NOT NULL -- 'Total wait time of the summarized events that are timed.',
+    `MIN_TIMER_WAIT` bigint(20) unsigned NOT NULL -- 'Minimum wait time of the summarized events that are timed.',
+    `AVG_TIMER_WAIT` bigint(20) unsigned NOT NULL -- 'Average wait time of the summarized events that are timed.',
+    `MAX_TIMER_WAIT` bigint(20) unsigned NOT NULL -- 'Maximum wait time of the summarized events that are timed.',
+    `COUNT_READ` bigint(20) unsigned NOT NULL -- 'Number of all read operations, including FGETS, FGETC, FREAD, and READ.',
+    `SUM_TIMER_READ` bigint(20) unsigned NOT NULL -- 'Total wait time of all read operations that are timed.',
+    `MIN_TIMER_READ` bigint(20) unsigned NOT NULL -- 'Minimum wait time of all read operations that are timed.',
+    `AVG_TIMER_READ` bigint(20) unsigned NOT NULL -- 'Average wait time of all read operations that are timed.',
+    `MAX_TIMER_READ` bigint(20) unsigned NOT NULL -- 'Maximum wait time of all read operations that are timed.',
+    `SUM_NUMBER_OF_BYTES_READ` bigint(20) NOT NULL -- 'Bytes read by read operations.',
+    `COUNT_WRITE` bigint(20) unsigned NOT NULL -- 'Number of all write operations, including FPUTS, FPUTC, FPRINTF, VFPRINTF, FWRITE, and PWRITE.',
+    `SUM_TIMER_WRITE` bigint(20) unsigned NOT NULL -- 'Total wait time of all write operations that are timed.',
+    `MIN_TIMER_WRITE` bigint(20) unsigned NOT NULL -- 'Minimum wait time of all write operations that are timed.',
+    `AVG_TIMER_WRITE` bigint(20) unsigned NOT NULL -- 'Average wait time of all write operations that are timed.',
+    `MAX_TIMER_WRITE` bigint(20) unsigned NOT NULL -- 'Maximum wait time of all write operations that are timed.',
+    `SUM_NUMBER_OF_BYTES_WRITE` bigint(20) NOT NULL -- 'Bytes written by write operations.',
+    `COUNT_MISC` bigint(20) unsigned NOT NULL -- 'Number of all miscellaneous operations not counted above, including CREATE, DELETE, OPEN, CLOSE, STREAM_OPEN, STREAM_CLOSE, SEEK, TELL, FLUSH, STAT, FSTAT, CHSIZE, RENAME, and SYNC.',
+    `SUM_TIMER_MISC` bigint(20) unsigned NOT NULL -- 'Total wait time of all miscellaneous operations that are timed.',
+    `MIN_TIMER_MISC` bigint(20) unsigned NOT NULL -- 'Minimum wait time of all miscellaneous operations that are timed.',
+    `AVG_TIMER_MISC` bigint(20) unsigned NOT NULL -- 'Average wait time of all miscellaneous operations that are timed.',
+    `MAX_TIMER_MISC` bigint(20) unsigned NOT NULL -- 'Maximum wait time of all miscellaneous operations that are timed.'
+    );
+</schema>
+<question>
+List out 10 names of the files with the most read and writes
+</question>
+<sql>
+"""
+```
+
+### response
+```sql
+SELECT FILE_NAME FROM file_summary_by_instance ORDER BY SUM_NUMBER_OF_BYTES_READ DESC, SUM_NUMBER_OF_BYTES_WRITE DESC LIMIT 10;
+```
+
+
+### 4. Function Calling
+
+### prompt
+```python
+prompt = """
+Give a function call in python langugae for the following question:
+<example_response>
+--doc: Description: This function logs a curl command in debug mode.
+Parameters:
+- method (str): The HTTP method to use for the request.
+- url (str): The URL to send the request to.
+- data (dict, optional): The data to send in the request. Defaults to None.
+- headers (dict, optional): The headers to send with the request. Defaults to None.
+- level (int, optional): The log level to use for this log message. Defaults to logging.DEBUG.
+Returns:
+- None
+Example:
+log_curl_debug('GET', 'https://example.com')
+--question: log a curl PUT request for url https://web.io/
+--function_call: log_curl_debug(method='PUT', url = 'https://web.io')
+</example_response>
+<doc>
+Function Name: make_get_req()
+Description: This function is used to make a GET request.
+Parameters:
+- path (str): The path of the URL to be requested.
+- data (dict): The data to be sent in the body of the request.
+- flags (dict): The flags to be sent in the request.
+- params (dict): The parameters to be sent in the request.
+- headers (dict): The headers to be sent in the request.
+- not_json_response (bool): OPTIONAL: If set to True, the function will return the raw response content instead of trying to parse it as JSON.
+- trailing (str): OPTIONAL: For wrapping slash symbol in the end of string.
+- absolute (bool): OPTIONAL: If set to True, the function will not prefix the URL with the base URL.
+- advanced_mode (bool): OPTIONAL: If set to True, the function will return the raw response instead of trying to parse it as JSON.
+Returns:
+- Union[str, dict, list, None]: The response content as a string, a dictionary, a list, or None if the response was not successful.
+</doc>
+<instruction>
+1. Strictly use named parameters mentioned in the doc to generate function calls.
+2. Only return the response as python parsable string version of function call.
+3. mention the 'self' parameter if required.
+</instruction>
+<question>
+Make a GET request for the URL parameter using variable_2. For the params parameter, use 'weight' as one of the keys with variable_3 as its value, and 'width' as another key with a value of 10. For the data parameter, use variable_1. Prefix the URL with the base URL, and ensure the response is in raw format.
+</question>
+<function_call>
+"""
+```
+
+### response
+```python
+make_get_req(path='https://example.com/api/v1/users', data=variable_1, params={'weight': variable_3, 'width': 10}, headers={'Content-Type': 'application/json'}, not_json_response=True, absolute=True)
+```
+
+### prompt
+```python
+prompt = """
+Give only function call in python langugae as response for the following question:
+<example_response>
+--doc:
+Function:
+Help on function head in module pandas.core.generic:
+
+head(self, n: 'int' = 5) -> 'Self'
+Return the first `n` rows.
+
+This function returns the first `n` rows for the object based
+on position. It is useful for quickly testing if your object
+has the right type of data in it.
+
+For negative values of `n`, this function returns all rows except
+the last `|n|` rows, equivalent to ``df[:n]``.
+
+If n is larger than the number of rows, this function returns all rows.
+
+Parameters
+----------
+n : int, default 5
+Number of rows to select.
+
+Returns
+-------
+same type as caller
+The first `n` rows of the caller object.
+
+See Also
+--------
+DataFrame.tail: Returns the last `n` rows.
+
+Examples
+--------
+>>> df = pd.DataFrame({'animal': ['alligator', 'bee', 'falcon', 'lion',
+... 'monkey', 'parrot', 'shark', 'whale', 'zebra']})
+>>> df
+animal
+0 alligator
+
+--question: Get the top 5 rows with the highest Engagement_Score. Parameter Description: Use 5 as Number of rows to return ,Use variable_3 as Sorted DataFrame, Do not call any other function, Pass variable to self parameter for method calls
+--function_call: head(self=variable_3, n=5)
+</example_response>
+<doc>
+Function: sort_values
+sort_values in module pandas.core.frame:
+sort_values(self, by: 'IndexLabel', *, axis: 'Axis' = 0, ascending: 'bool | list[bool] | tuple[bool, ...]' = True, inplace: 'bool' = False, kind: 'SortKind' = 'quicksort', na_position: 'str' = 'last', ignore_index: 'bool' = False, key: 'ValueKeyFunc | None' = None) -> 'DataFrame | None'
+Sort by the values along either axis.
+Parameters
+----------
+by : str or list of str
+Name or list of names to sort by.
+
+- if `axis` is 0 or `'index'` then `by` may contain index
+levels and/or column labels.
+- if `axis` is 1 or `'columns'` then `by` may contain column
+levels and/or index labels.
+axis : "{0 or 'index', 1 or 'columns'}", default 0
+Axis to be sorted.
+ascending : bool or list of bool, default True
+Sort ascending vs. descending. Specify list for multiple sort
+orders. If this is a list of bools, must match the length of
+the 
+</doc>
+<instruction>
+1. Strictly use named parameters mentioned in the doc to generate function calls.
+2. Only return the response as python parsable string version of function call.
+3. Use the 'self' parameter if required in the function call with it's value in named keyword format.
+</instruction>
+<question>
+Using the above function, Sort the DataFrame by the Engagement_Score in descending order. Parameter Description: Use Engagement_Score as Column name to sort by ,Use False as Sort in descending order ,Use variable_1 as DataFrame to sort, Do not call any other function, Pass variable to self parameter for method calls
+</question>
+<function_call>
+"""
+```
+### response
+```python
+sort_values(self=variable_1, by='Engagement_Score', ascending=False)
+```
+
+
+
+### Team
+Avi Kothari, Gyan Ranjan, Pratham Gupta, Ritvik Aryan Kalra, Soham Acharya