Descript is building the next generation platform for creative tools, making audio and video creation as fast, accessible, and collaborative as Google Docs

Descript

Last week I was talking about job applications and not holding yourself back by saying “no” pre-emptively. I started to dive into job descriptions before realizing they deserved their own post. Which is what I’m talking about today. I’m not going to sugar-coat it: Job descriptions are often a complete work of fiction. Sometimes, this is because the job description is years out of date – written before the previous employee in that role (or the one before  that) had even started. The original responsibilities morphed and  changed with the needs of the moment and the skills of the people, but the job description remained unchanged. Sometimes the job description started out realistically but then HR (or the “AI”-driven tool HR is using) decides to add other requirements  to better match similar job descriptions out of standardized databases –  which are themselves nothing more than amalgams of job descriptions  sourced across time and distance. It’s job-description-by-committee,  with no bearing on reality. Sometimes HR offers a single open req (when 3 are needed) so the manager tries to create a wish-list of requirements and  responsibilities, in the hope that someone will come along with most (or  at least many) of the boxes checked. It’s a pipe dream, but a  frustratingly common one. Regardless of the reason, the truth remains that many of the job descriptions out there are nothing more than a messy collection of vague  hopes, wishful thinking, and out-of-date ideas. Over three decades an nearly 20 jobs, I’ve lost count of the number of times I’ve shown up for an interview only to discover that the work  bore NO resemblance to the requirements on paper. What I find more  astonishing is that sometimes the manager knew this was the case, but  often they didn’t. The lesson in all of this goes back to the core message of the : In your job hunt, job is to apply. Don’t second guess whether you have “enough” of the  skills, because – as I’ve just explained – the work their need done may  be very different. last post your Do you like the company because of it’s culture, creation, community, calling, or some other aspect? Are you intrigued enough to want to find  out more? That’s all it takes. Apply. Also published . here

Job Descriptions and Their Fictional Hiring Expectations

Meta description summarizes a web page’s content and displays it in the search engine results. It tells the user what this web page contains without opening that link. It lets users choose which web page can provide the desired information that they are looking for. , For example If you are searching on Google for “best app for calorie tracking,” then you will see the following results. In the above picture, the section is highlighted by a red square showing a meta description on the search engine result page. By reading these descriptions, you can find out which web page can provide more accuracy as per the search query. It means meta descriptions can help in increasing the number of clicks to your website. And, it is imperative to include important details in limited char limits. The meta description should not be more than because Google truncates details beyond this limit. You will not want to cut out an important part of the description. Therefore, try to limit it to 160 characters. 160 characters Most websites have only a few web pages and it is easy to write meta descriptions of those pages. However, e-commerce websites have thousands of products. Writing a meta description for thousands of pages is a time-consuming process. With the help of SheetGPT, you can speed up the process. How SheetGPT Helps To Quickly Write Hundreds Of Meta Descriptions Quickly? Before moving to the approach for writing hundreds of meta descriptions quickly, let’s discuss sheetGPT. SheetGPT is a tool that helps you to integrate Open AI’s text and image generation abilities with Google Sheets. With this integration, you can leverage the abilities of both Google Sheets and Open AI. Imagine how easily you can enhance your productivity. Though there are endless ways to leverage this integration, we are going to discuss only one here. Here, we are going to describe a step-by-step approach for writing hundreds of meta descriptions seamlessly. Steps For Writing Hundreds Of Meta Descriptions Seamlessly 1. Make A List Of URLs On Google Sheet As we have mentioned, you have to use the power of Google Sheets, therefore, you should create a list of all URLs for which you want to write meta descriptions. Moreover, by creating a list on Google Sheets, you can easily track each URL. I have created a list of 500 plus URLs which I have shown below. Here, I am taking an example of a ‘CBD To Me’ website with hundreds of product pages for which we need meta descriptions. 2. Integrate Open AI’s GPT With Google Sheet To leverage the power of AI in Google Sheets, you need to install the extension SheetGPT. To use SheetGPT on Google Sheets, you need to consider the following steps: Click on the ‘ ’ shown as the ‘ Symbol on the right-hand side of the Google Sheets. If you are not able to find this option on your Google Sheets, then Click ‘ ’ → ‘ ’. Get Add-Ons +’ Extensions Get Add-Ons A new pop-up window ‘ ’ will open. Here, you will see various options for extensions to add to your Google Sheet. Google Workspace Marketplace If is visible in displayed apps, then click on it. Otherwise, the search option is available at the top right of this window. You can for this app from this option available in this marketplace. SheetGPT Search SheetGPT - AI and ChatGPT for sheets and you will see the ’ button. Click on this button. ‘Install In the next step, you have to choose your . Agree with the Privacy Policy and Terms Of Service of SheetGPT by clicking on the ‘ ’ button and → ‘ ’ button. With this installation process will be completed. Google account to Sign In Continue Allow After that, come back to Google Sheets and click on ‘ ’ options → → Extensions SheetGPT- AI and GPT for Sheets Enable GPT functions. By following the above-mentioned steps, you can use GPT functions on your Google Sheets. 3. Use GPT Functions Now, it is time to use GPT functions to quickly and easily write meta descriptions of web pages for e-commerce websites. This technique is helpful in e-commerce websites because URLs of web pages of these kinds of websites contain most of the important details about products. Now, write the in the row adjacent to the list of URLs. Write function as shown below: GPT function After that, click and drag till you reach the last column of URLs. You will see that Meta descriptions will automatically start updating for each column. Voila, with this drag, you can quickly complete your hundreds of descriptions in no time. Keep in mind that you can use this function of SheetGPT only one time. To use it for multiple times, you need to purchase it. Note: 4. Check the Total Characters In Each Description According to Google guidelines, the length of meta descriptions should not exceed the limit of 160 characters. I would like to recommend you keep all meta descriptions length between 130 to 155 characters. To ensure that each meta description falls inside this character length, you should leverage the amazing features of Google Sheets. Again, use a formula to quickly determine the length of every description created by OpenAI’s GPT. Write a formula in the next row adjacent to the meta descriptions row. Formula to Use =LEN(cell) Now, you can easily determine which meta description is falling inside the desired limit. The meta descriptions that are below or above the threshold limits need alterations or editing. 5. Proofread And Give Final Touch As you know AI-generated content may not be as per our expectations. Therefore, it is important to proofread every description and give human touch. By adding a human touch you can make these descriptions fruitful and worthy. Final Words Artificial intelligence is here to make things easy and reduce time for completing tasks. OpenAI’s ChatGPT has vast potential. We just need to find different ways to use it. In this article, it is shown how you can use the alluring features of SheetGPT and Google Sheets to speed up the process of writing hundreds of meta descriptions. It is time to focus on the next-level marketing strategy. Writing meta descriptions is quite a time-consuming and boring task. Automate this process with the help of Open AI.

Using SheetGPT to Create Meta Descriptions for Your Website

Common Sense Applied to Religion; Or, The Bible and the People by Catharine Esther Beecher, is part of the HackerNoon Books Series. You can jump to any chapter in this book . CLASSIFICATION AND DESCRIPTION OF THE MENTAL POWERS. here CHAPTER VIII. CLASSIFICATION AND DESCRIPTION OF THE MENTAL POWERS. We now proceed to the classification and description of the mental powers. Not only all writers on mental science, but the most common writers and speakers, recognize a general division of mental operations, which is expressed by the terms , , and . We , we , and we . Even the young child learns to comprehend these three grand divisions of the mental phenomena. intellect feeling choice think feel choose To this most general division, in this work, are applied the terms , and . These terms are selected because they are the most common ones. the intellectual powers, the susceptibilities the will THE INTELLECTUAL POWERS. Under the general class of intellectual powers are arranged the following specific powers of mind: Sensation, Perception, Conception, Memory, Imagination, Judgment, Abstraction, Attention, and Association. is a state of mind produced by material objects acting on the senses. Sensation Thus, when light, which is considered as one kind of matter, affects the eye, the sensation of is produced. When the perfume of a rose, which is another species of matter, affects the nostrils, the sensation of is produced. When a bell or some musical instrument causes the air to vibrate on the drum of the ear, it causes the sensation of . When any sapid body is applied to the tongue, the sensation of is caused. When the hand, or any part of the body, comes in contact with another body, the sensation of is produced. sight smell sound taste touch Thus it appears that the five senses are the organs of sensation, and that through their instrumentality material things operate upon the mind. is a attended by the , and it is this additional circumstance alone which distinguishes perception from sensation. Perception sensation belief of a cause If a person were asleep, and should suffer from the prick of a pin, or be disturbed by an unpleasant sound, these would be mere sensations, because the mind would not ascribe them to any cause. But if the person should waken, these sensations would immediately become perceptions, because they would be attended by the belief of some cause. is a state of mind similar to perception, and differs from it in being less vivid, and in not being produced through the medium of the senses. Conception When we look at a tree, we have a of this object. But the mind can also have an idea of this tree when removed from the sight, though the idea is not so vivid and distinct, nor have the senses any agency in producing it. The perfume of a rose, also, occasions another sensation; but when the rose is removed, so as not to affect the senses, we can still have a of its perfume. The conception differs from the perception only in being less vivid, and in not being caused by a material object acting on the senses. perception conception is either a conception or a perception, which is attended with a feeling of its resemblance to a past state of mind. It is this feeling of resemblance that is the only circumstance which distinguishes memory from conception. Memory Thus we may conceive of a tree without recognizing it as the particular idea of any tree we may have seen before; but if this is accompanied by a feeling of the resemblance of this idea to the one we always have when we see the tree that shadows the paternal roof, this conception becomes . If we conceive the form of a man without recognizing the resemblance of this idea to the perceptions we have when we see any particular man, this is a simple act of conception; but if we recognize in this object of conception the features of a dear friend, this act then becomes memory. Again, if we conceive of certain events and circumstances attending them without recognizing this combination as ever having existed in past experience, they are mere conceptions; but if we recognize in them the events and circumstances of past experience, conception becomes memory. memory is the power which the mind possesses of arranging our conceptions in new combinations. We can conceive objects as united together of which we never conceived before as thus united. Imagination Thus, when we read the description of some picturesque scene in nature, the mind immediately groups together mountains, trees, brooks, cottages, and glens, forming a new combination of conceptions different from any scene we ever witnessed or conceived before. All the objects thus combined are conceptions; the act of arranging them is an act of the imagination. is the power which the mind possesses of . A is an idea obtained by observing one thing in connection with another. Thus, when we perceive one thing to be than another, one thing to be another, or one thing to to another—in all these cases the mind , or exercises the faculty of judgment. Thus, also, when we compare any action with the rule of duty in order to decide whether it is right or wrong, we exercise the same faculty. This act always is necessarily preceded by the comparison of one thing with another, in order to notice the relations. Judgment noticing relations relation longer on belong notices relations is the power of noticing certain parts or qualities of any object, as distinct from other parts or qualities. Thus, when we notice the length of a bridge without attending to the breadth or color, or when we notice the height of a man without thinking of his character, we exercise the faculty of abstraction. Abstraction is the direction of the mind to any particular object or quality, from the interest which is felt in it, or in something connected with it. The degree of attention is always proportioned to the degree of interest felt in the object. Attention is the power possessed by the mind of recalling ideas in the connections and relations in which they have existed in past experience. For example, when any two objects, such as a house and a tree, have often been observed together, the idea of one will ordinarily be attended by that of the other. If two events have often been united together in regard to the of their occurrence, such, for example, as thunder and lightning, the idea of one will usually be attended by the other. Association time In this work, the aim is to introduce no more of mental analysis than is needed for its main object. What is here introduced is not claimed as a complete presentation of all the mental phenomena. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Catharine Esther Beecher (2017). Common Sense Applied to Religion; Or, The Bible and the People. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/55531/pg55531-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

CLASSIFICATION AND DESCRIPTION OF THE MENTAL POWERS.

offers a range of powerful features for object-oriented programming, including descriptors. These enable you to define how class attribute modification and access occur, making it useful for enforcing value constraints, implementing computed properties, and customizing attribute access. Python This article covers the fundamentals of descriptors and provides guidance on how to implement them in your Python code. It addresses the following questions: what is the definition of a descriptor how to create a descriptor from scratch how the descriptors actually work what can be built using descriptors Descriptors may sound unfamiliar to you, but they are widely used in popular packages such as Django and SQLAlchemy. This article will provide you with a clear understanding of descriptors and enable you to develop your own. Content Overview Anatomy of a Descriptor JSON Attribute Descriptors are Ubiquitous Summary Sources Anatomy of a Descriptor A descriptor is a type of class that includes either of the , , or methods. When an instance of this class is used as an attribute in another class, it is referred to as a . To illustrate, here is an example of a basic descriptor class and how it can be used as a managed attribute: __get__ __set__ __delete__ managed attribute class PositiveInt:
    def __init__(self, name: str) -> None:
        self.name = name

    def __set__(self, obj: object, value: int) -> None:
        if value <= 0:
            raise ValueError(f"Value of '{self.name}' must be a positive int")
        obj.__dict__[self.name] = value

    def __get__(self, obj: object, cls: type) -> int:
        return obj.__dict__[self.name]


class SomeClass:
    x = PositiveInt("x")
    y = PositiveInt("y")

    def __init__(self, x: int, y: int) -> None:
        self.x = x
        self.y = y


some_object = SomeClass(1, 2)
print(some_object.x)
print(some_object.y)
some_object.y = 0 The descriptor is used to set integer attributes in a class. Its primary function is to ensure that the number passed is greater than zero. This check is performed within the magic method, which is triggered whenever a new value is assigned to an attribute. If the value is valid, it is stored in the instance's dictionary of writable attributes, called . PositiveInt __set__ __dict__ There are a few important things to note about the structure. Firstly, it also includes the method. This is necessary in order to retrieve the value from the original class. However, the method is not included. It was needed for this particular example, and it is acceptable for a descriptor class to not implement it. In fact, a descriptor class only needs to include one of the three methods. Finally, it is worth noting that inheritance is not required in order to implement a descriptor. This is because descriptors are protocol-based feature. PositiveInt __get__ __del__ When the code is executed, the output is as follows: 1
2
Traceback (most recent call last):
	# trunkated
ValueError: Value of 'y' must be a positive int The final workflow appears like there are regular attributes, but in reality, the power of Python Data Model lies in its ability to handle complex implementation behind the scenes. In this case, the descriptor manages the assignment and retrieval of values. The values are initially set in the method, and then, an error occurs due to the last assignment. __init__ Upon examining , it may seem more practical to store the value within the descriptor rather than in the original class. This can be achieved by adding in the method. To investigate such a case, take a look at the "improved" example: PositiveInt self.__dict__[self.name] = value __set__ class NegativeInt:
    def __init__(self, name: str) -> None:
        self.name = name

    def __set__(self, obj: object, value: int) -> None:
        if value >= 0:
            raise ValueError(f"Value of '{self.name}' must be a negative int")
        self.__dict__[self.name] = value

    def __get__(self, obj: object, cls: type) -> int:
        return self.__dict__[self.name]


class DifferentClass:
    x = NegativeInt("x")


some_object = DifferentClass()
some_object.x = -5
print(some_object.x)

different_object = DifferentClass()
different_object.x = -6
print(different_object.x)

print(some_object.x) The descriptor functions similarly to , but in the opposite direction. It also operates on data that is stored within the descriptor class. The following result is produced when executing this code: NegativeInt PositiveInt -5
-6
-6 It appears that changing the value of to -6 also changed the value of the attribute. This is because descriptors are class attributes that are initialized only once during import time. Therefore, both objects of the share the same descriptor object. To ensure proper functioning, the descriptor object must be smart enough to work with the data of the object it belongs to. different_object.x some_object DifferentClass In previous examples, it was necessary to manually set the name and retrieve the value using that name. However, this approach can lead to repetitive code in all descriptors. Thankfully, the magic method provides a solution. When the interpreter calls this method on all descriptors in the class, it eliminates the need for repetitive and methods. For instance: __set_name__ __init__ __get__ class PositiveInt:
    def __set_name__(self, owner: type, name: str):
        self.name = name

    def __set__(self, obj: object, value: int) -> None:
        if value <= 0:
            raise ValueError(f"Value of '{self.name}' must be a positive int")
        obj.__dict__[self.name] = value


class SomeClass:
    x = PositiveInt()
    y = PositiveInt()

    def __init__(self, x: int, y: int) -> None:
        self.x = x
        self.y = y


some_object = SomeClass(1, 2)
print(some_object.x)
print(some_object.y) The descriptor remains the same as before, but it no longer contains the method. Instead, it includes the method, which will be called with the and names in this particular case. This modification means that the method implementation is also unnecessary, as the attribute name is identical in both classes, and the value can be retrieved from the instance. PositiveInt __init__ __set_name__ x y __get__ SomeClass Now with the anatomy of descriptors covered, you should have a solid understanding of how they function. The next section will go over the implementation of a more real-world scenario. JSON Attribute Descriptors are an embodiment of encapsulation. They hide implementation and complexity, making them perfect for validation, caching, and interacting with non-in-memory storage like databases and file systems. For example, the descriptor works with files while the target class declares attributes as usual. JSONAttribute JSON import json
from typing import Any


class JSONAttribute:
    """A descriptor for working with JSON files."""

    def __set_name__(self, owner: type, name: str):
        self.name = name
        self.path = f"{owner.__name__}.json"

    def __set__(self, obj: object, value: Any) -> None:
        """Set the value in the JSON file."""
        try:
            f = open(self.path, "r+")
            content = json.load(f)
        except FileNotFoundError:
            f = open(self.path, "a+")
            content = {}

        content[self.name] = value
        f.seek(0)
        json.dump(content, f, indent=4)
        f.close()

    def __get__(self, obj: object, owner: type) -> Any:
        """Get the value from the JSON file."""
        try:
            f = open(self.path, "r")
        except FileNotFoundError:
            f = open(self.path, "a+")
            json.dump({}, f)
            return None

        value = json.load(f).get(self.name)
        f.close()
        return value


class JSONReaderWriter:
    x = JSONAttribute()
    y = JSONAttribute()


rw = JSONReaderWriter()
rw.x = 1
rw.y = 2
print(rw.x, rw.y) Without delving too deeply into the details of implementation, has three core functionalities: json JSONAttribute creating a JSON file named after the class it is used in setting the value of an attribute inside the JSON file retrieving the value of the attribute from the JSON file When executed, this code, of course, prints , but more importantly, the file is created and the values are stored inside it. This is impressive because the end user of this code sees the values coming from the instance of the class, but they are actually nowhere to be found within it. 1 2 JSONReaderWriter.json You have now seen a real-world use case and should be able to implement a descriptor for your own needs. The final chapter covers some of the most popular descriptor examples. Descriptors are Ubiquitous As mentioned previously, even if you haven't been familiar with descriptors, you've probably used them before, without realizing it. One common example is the decorator, which is a descriptor factory that creates a descriptor. The decorated method acts as a getter, but you can also implement setter and deleter methods. property Another popular example includes models and fields in Django. In this case, descriptors are a way to abstract away the details of working with a database, or a file system. However, Django uses metaclasses on top of descriptors, making the process more complex. An example of a more modern Python library is Pydantic fields. They behave similarly to Django in that they also "hide" field behavior. However, in this case, descriptors are used to provide additional information about the field and attach necessary validation. Summary Descriptors are one of the features that make Python's OOP so unique. They allow for powerful customization of attribute access and manipulation. This article explored the topic of descriptors, covering how to build them, what they can be used for, and what descriptors developers are encountering on a daily basis. Hopefully, you gained some valuable insights and you are able to work with descriptors in your projects. Sources Code examples used in the article can be found here: . link The biggest inspiration for these articles and source of my knowledge is the book by Luciano Ramalho. I highly encourage you to check it out; you will not be disappointed. Fluent Python Also published here.

Implementing Descriptors in Your Python Code 

Knowledge by Acquaintance vs Knowledge by Description

In our company, which is engaged in online sales of electronic components, creating product descriptions is quite a labor-intensive process, especially when it comes to some obscure chip with little information available or information in unknown languages. After the release of Chat GPT-4 by OpenAI, we tested its ability to generate descriptions for obscure products for online stores. We were pleasantly surprised when, in some cases, it outperformed our content manager and did it much faster. It became clear that we could now increase the speed of adding new product listings to our website and do it much more cost-effectively, while the services of the content manager would still be needed for creating descriptions for products unknown to Chat GPT-4 and for reviewing the generated responses before publishing. It turned out that we started using PrestaShop from the beginning of our company's establishment, although we have since moved away from this CMS. PrestaShop is quite a popular e-commerce engine, and I thought someone might find that interesting. Today we will be creating a module for generating product descriptions using Chat GPT-4 in an online store based on PrestaShop. This will simplify the life of the content manager. The content manager will only need to fill in the product name field, and the module will generate the description based on it. I will demonstrate an example on PrestaShop version 8.0.4, but the same method will work for most older versions of PrestaShop and probably for new ones as well. Creating modules in PrestaShop is not difficult, and I believe it won't pose any challenges, even for beginners. To start, create a directory with the name of our module in the /modules/ directory, for example: /gptdescription Now, in the directory, create a file with the same name as our module: gptdescription.php /modules/gptdescription In this file, we will have all the main code of the module. Create a class in it that should inherit from the Module class. class GPTDescription extends Module
{


} First, let's add a constructor: private $api_key;
private $model;


public function __construct()
{
    $this->name = 'gptdescription';
    $this->tab = 'administration';
    $this->version = '0.1';
    $this->author = 'sinenko';
    $this->need_instance = 0;
    $this->ps_versions_compliancy = ['min' => '8.0.4', 'max' => '8.0.4'];
    $this->bootstrap = true;


    $this->api_key = Configuration::get('GPT4INTEGRATION_API_KEY'); // API key
    $this->model = Configuration::get('GPT4INTEGRATION_MODEL'); // GPT model


    parent::__construct();


    $this->displayName = $this->l('GPT-4 product description generator');
    $this->description = $this->l('Automatically generate product descriptions using GPT-4.');


    $this->confirmUninstall = $this->l('Are you sure you want to uninstall?');
} In the constructor, we specify the name, version, author, and description of our module, which will be displayed during the installation and uninstallation of the module. We also specify two parameters, api_key and model, which will be configurable in the module's configuration through the admin panel. Now let's create a method that will generate a description based on the product title. private function generateDescription($productTitle)
{
    $api_key =  $this->api_key;
    $model = $this->model;


} In this method, we will use CURL to make requests to the OpenAI API and generate our description. To obtain an API key, we need to go to the following link: and complete the registration process. After registration, you need to create a new API key and save it. We will specify this key in the settings of our future module. https://platform.openai.com/account/api-keys Now let's go to the documentation and see which models are currently available to us at . https://platform.openai.com/docs/models At the time of writing this article, specifically in May 2023, the following models are available: We are interested in GPT-4 (Limited beta as of May 2023), and if you don't have access to the GPT-4 model, we will add the ability to switch to GPT-3.5 in our module: gpt-4 gpt-4-0314 gpt-4-32k gpt-4-32k-0314 GPT-3.5: gpt-3.5-turbo gpt-3.5-turbo-0301 text-davinci-003 text-davinci-002 code-davinci-002 Based on my small tests, we will use gpt-4 and gpt-3.5-turbo as they are more suitable for generating product descriptions. Now, according to the documentation at , to interact with the chat, we need to send a POST request to the following URL in the following format: https://platform.openai.com/docs/api-reference/chat https://api.openai.com/v1/chat/completions {
    "model": "gpt-4", // Selected GPT model
    "messages": [
      {
        "role": "assistant", // Role of the assistant
        "content": "Please make a product description for me" // Text of the request
      }
    ],
    "max_tokens": 4000, // Maximum number of tokens in the response
    "n": 1, // Number of text variants
    "stop": [ // Up to 4 sequences where the API will stop generating further tokens.
      "\\n"
    ],
    "temperature": 0.1 // Temperature (creative component)
  } In the "content" parameter, we will pass our prompt query to the chat for generating the description. "max_tokens" is the token limit for the response. OpenAI charges for API usage based on the number of tokens used for the request and response. Therefore, the shorter the query and the shorter the response, the cheaper it will be for you to generate the product description. If you're not familiar with tokens, you can think of one token roughly equaling one word. Prices at the time of writing this article are as follows: GPT-3.5-turbo $0.002/1K tokens of all GPT-4 8K $0.03/1K tokens of promts $0.06/1K tokens of response GPT-4 32K$0.06/1K tokens of promts$0.12/1K tokens of response The lower the "temperature" parameter, the more precise and deterministic the chat will generate the product description. You can experiment with it depending on the type of products in your catalog. Let's make a test request to the API and see the format of the response. private function generateDescription($productTitle = '74HC4066N')
{
    $api_key =  'your_key';
    $model = 'gpt-4';


    if (!$api_key || empty($api_key) || !$model || empty($model)) {
        return null;
    }


    $url = 'https://api.openai.com/v1/chat/completions'; // URL GPT-4 API


    $prompt = 'make a product description for online-store: ';
    $prompt .= $productTitle;


    $data = [
        'model' => $model, // Selected GPT model
        'messages' => [[
            'role' => 'assistant',
            'content' => $prompt // Text of the request
        ]],
        'max_tokens' => 4000, // Maximum number of tokens in the response
        'n' => 1, // Number of text variants
        'temperature' => 0.1 // Temperature (creative component)
    ];


    $headers = [
        'Content-Type: application/json',
        'Authorization: Bearer ' . $api_key
    ];


    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch); 
    curl_close($ch);


    print_r($response);


} After the request, we receive the following response: {
    "id": "chatcmpl-7EbpN1nlH4PwMQ3YPmVcoMspPNtqy",
    "object": "chat.completion",
    "created": 1683716357,
    "model": "gpt-4-32k-0314",
    "usage": {
      "prompt_tokens": 11,
      "completion_tokens": 219,
      "total_tokens": 230
    },
    "choices": [
      {
        "message": {
          "role": "assistant",
          "content": "Product Title: 74HC4066N Quad Bilateral ..... Add it to your cart now!"
        },
        "finish_reason": "stop",
        "index": 0
      }
    ]
  } We can see that the response includes the number of tokens used for the request and response, which allows us to analyze the service load and estimate the cost of generating our descriptions. The chat-generated messages in response to our request are stored in the "choices" array. The "message" objects contain the "content" parameter, which is the description of our product. I made a request for generating a description for the 74HC4066N microchip, and the complete chat response looks as follows: Product Title: 74HC4066N Quad Bilateral Switch IC

Product Description:

The 74HC4066N is a high-speed Si-gate CMOS device, built to provide exceptional performance in a wide range of applications. As a quad bilateral switch, it integrates four independent switches into one compact package, with each switch having two input/output terminals and an active HIGH enable input.

Key Features:

1. Quad Bilateral Switch: The 74HC4066N houses four independent switches, allowing for versatile usage in various electronic circuits.

2. High-Speed CMOS Logic: Designed for optimal performance, the 74HC4066N is built with high-speed CMOS logic, ensuring fast and efficient operation.

3. Low Power Dissipation: This device offers low power dissipation, making it ideal for battery-powered or energy-efficient applications.

4. Versatility: Each switch in the 74HC4066N can pass both digital and analog signals, from DC up to the MHz range, making it suitable for a diverse range of applications.

5. Low ON Resistance: The device offers low "on" resistance, ensuring maximum signal integrity.

Applications:

The 74HC4066N is perfect for a variety of applications, including signal gating, chopping, modulation or demodulation (modem), and signal multiplexing for analog-to-digital and digital-to-analog conversion systems.

Package Information:

This IC comes in a 14-pin PDIP (Plastic Dual-In-line Package), designed for easy integration into your circuit board.

The 74HC4066N is an ideal choice for designers and hobbyists looking for a versatile, high-performance switch IC. Its consistent performance and reliability make it a staple in any electronic toolkit. 

Please note: Always ensure that you operate this device within its recommended specifications to guarantee its longevity and performance.

If you're looking for an efficient and versatile switch for your electronic projects, the 74HC4066N Quad Bilateral Switch IC is the perfect choice. Add it to your cart now! As we can see, the product description is very clear and well-written, almost comparable to what a content manager would have written. Now let's complete our function and add the ability to edit and save the product descriptions. Additionally, PrestaShop supports product descriptions in HTML format, so we can modify our prompt to specify that the product description should be formatted with HTML tags. We can also notice that ChatGPT suggests not only the description but also the title of the product. Let's ask GPT to format the response and indicate where the title of the product is and where the short description, and we will save this information in the corresponding fields in PrestaShop. The new prompt will look as follows: $prompt = 'Provide an answer: a description with product specifications for an online store in pure html format (without classes, styles, and id, give the product title id="product-title", make the product summary id="product-summary",  make the product description and key-features id="product-description "), if the product is unknown to you, then write {not-found}: '; Now the product description will look as follows: <div>
  <h1 id="product-title">74HC4066N Quad Bilateral Switch IC</h1>
 
  <p id="product-summary">
    The 74HC4066N is a high-speed Si-gate CMOS device, offering exceptional performance in a wide range of applications. As a quad bilateral switch, it integrates four independent switches into one compact package.
  </p>


  <div id="product-description">
    <h2>Product Description and Key Features</h2>
    <p>
      1. <strong>Quad Bilateral Switch:</strong> The 74HC4066N houses four independent switches, allowing for versatile usage in various electronic circuits.
    </p>
    <p>
      2. <strong>High-Speed CMOS Logic:</strong> Designed for optimal performance, the 74HC4066N is built with high-speed CMOS logic, ensuring fast and efficient operation.
    </p>
    <p>
      3. <strong>Low Power Dissipation:</strong> This device offers low power dissipation, making it ideal for battery-powered or energy-efficient applications.
    </p>
    <p>
      4. <strong>Versatility:</strong> Each switch in the 74HC4066N can pass both digital and analog signals, from DC up to the MHz range, making it suitable for a diverse range of applications.
    </p>
    <p>
      5. <strong>Low ON Resistance:</strong> The device offers low "on" resistance, ensuring maximum signal integrity.
    </p>
    <p>
      This IC comes in a 14-pin PDIP (Plastic Dual-In-line Package), designed for easy integration into your circuit board. If you're looking for an efficient and versatile switch for your electronic projects, the 74HC4066N Quad Bilateral Switch IC is the perfect choice.
    </p>
  </div>
</div> Now we can easily parse this response into its components if needed. Additionally, if the GPT chat doesn't recognize such a product, it will return the response {not-found}. Let's complete the code that will return an array with the ready product description: // Checking if the response is set
if (isset($response_data['choices'][0]['message'])) {
    // Checking if the response is not {not-found}
    if ($response_data['choices'][0]['message']['content'] !== '{not-found}') {
        $result['content'] = $response_data['choices'][0]['message']['content'];


    }
   
    $pattern = '/<[^>]*id="product-title"[^>]*>(.*?)<\/[^>]*>/';
    preg_match($pattern, $response_data['choices'][0]['message']['content'], $matches_title);
   
    // Checking if the title is set
    if (!empty($matches_title)) {
        $result['title'] = $matches_title[1];
    }
   
   
    $pattern = '/<[^>]*id="product-summary"[^>]*>(.*?)<\/[^>]*>/';
    preg_match($pattern, $response_data['choices'][0]['message']['content'], $matches_summary);
   
    // Checking if the summary is set
    if (!empty($matches_summary)) {
        $result['summary'] = $matches_summary[1];
    }
   
    return $result;
} Now our function retrieves the product name, short description, and full description from the response of the GPT chat and returns a ready array for saving. Now we just need to save the obtained data into the necessary fields of PrestaShop. To do this, we will add a hook called hookActionProductUpdate to our module. This hook is executed when we update (edit and save) a product. Therefore, all the code we specify in this hook will be executed when the "Update" button is pressed in the product editing panel: public function hookActionProductUpdate($params)
{
    $product = $params['product'];


    // Checking if the description is already generated
    if($product->description[1] !== '{gpt}' && $product->description[1] !== '<p>{gpt}</p>') {
        return;
    }
    $productTitle = $product->name[1]; // Getting the product name
    $generatedDescription = $this->generateDescription($productTitle); // Generating the description


    if ($generatedDescription !== null) {
        if(!empty($generatedDescription['title'])) {
   
            $product->name[1] = $generatedDescription['title'];
        }
        if(!empty($generatedDescription['summary'])) {
            $product->description_short[1] = $generatedDescription['summary'];
        }
        if(!empty($generatedDescription['content'])) {
            $product->description[1] = $generatedDescription['content'];
        }
    }
    $product->validateFields();
} Here we specified that we need to generate a new description only if, when pressing the Update button during editing, the text {gpt} is present in the description field. In all other cases, the description will remain the same as before pressing the Update button. Our module is almost ready; we just need to make a small adjustment. I'm not sure about other versions of PrestaShop, but in version 8.0.3, the hook is called in the method after saving the product. Therefore, our changes will not be saved. Hence, we need to create a directory in our module called . In this directory, create a file named and override the method. In this method, we need to place the hook calls before saving the product. hookActionProductUpdate Product->update() override/classes Product.php update() Our module is ready; we just need to add installation, uninstallation, and create an interface for module configuration, specifically for entering the API key and selecting the model. I won't go into detail about this in the article, but you can view the complete module on GitHub. https://github.com/sinenko/gptPrestaProductDescription Now, after installing the module, we go to its settings and enter our API key. If you don't have access to the GPT-4 model, then switch the model to GPT-3.5. It is also capable of generating product descriptions, but it does it less effectively. Sometimes it adds nonexistent facts, and even if the model is not familiar with a particular product, it still tries to come up with a description for it, which may not be acceptable in our task. Now open our arbitrary product, enter the text {gpt} in the description field, and click on Update: After saving, we get a new title for the product and a short description generated by the GPT chat: Additionally, we have the full product description generated by the GPT chat: Thus, in less than an hour, we have created a module that has the potential to improve the quality of product descriptions and simplify the work of content managers. Moreover, based on this module, it is possible to create a module that translates product descriptions into other languages or corrects errors found in previously added products.

DESCRIPT

descript.com

-- employees

Since n.d.

COMPANY RANKING

DESCRIPT

EVERGREEN INDEX #3321

Representing this company? Click here to claim and customize this page!

Descript WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

DESCRIPT

descript.com

-- employees

Since n.d.

COMPANY RANKING

DESCRIPT

EVERGREEN INDEX #3321

RELATED COMPANIESRANK

STORIES ABOUT DESCRIPT

Representing this company? Click here to claim and customize this page!

Descript WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!