# Exploring The Python’s Square Number Calculation

A square arises when you take a number and multiply it by itself. This multiplication happens only once, as in: n multiplied by n. This operation is equivalent to elevating a number to the second power. Python offers multiple methods for calculating the square of a number.

Every method provides an accurate solution, without any being superior to the rest. Simply select the one that resonates with you the most.

## Square Number With Multiplication

A square represents a number that is the outcome of being multiplied by itself. Another way to achieve this result is by using the * symbol for direct multiplication. For instance, when we want to find the square of 4, we perform the following code:

```num = 4
square = num * num
print("Square number of", num, "is", square)

# Output: Square number of 4 is 16```

## Square Number With Exponent Operator **

Another technique for calculating the square of a number involves Python’s exponentiation (**) operator. The twin asterisks trigger Python’s exponentiation operation. To obtain a squared value, we can raise it to the power of 2. Hence, we input the number to be squared, followed by **, and conclude with 2. To illustrate, when seeking the square of 4, the code is as follows:

```num = 4
square = num ** 2
print("Square number of", num, "is", square)

# Output: Square number of 4 is 16```

## Square Number With Pow() Function

An additional method to compute the square of numbers involves using the built-in pow() function. This function raises a given value to a designated power. The initial parameter denotes the number requiring elevation, while the subsequent parameter signifies the exponent. In the case of squaring via pow(), the exponent is consistently set as 2. For instance, when the aim is to square 4, the procedure unfolds as:

```num = 4
square = pow(num, 2)
print("Square number of", num, "is", square)

# Output: Square number of 4 is 16```

## Square Number With Math.pow() Function

Another option for obtaining the square of a number is through the utilization of the math.pow() function. This function takes identical inputs, but generates a floating-point outcome.
So the code will resemble this:

```import math

num = 4
square = math.pow(num, 2)
print("Square number of", num, "is", square)

# Output: Square number of 4 is 16.0```

## Square Values In List or Array

The earlier instances solely concerned squaring individual values independently. Nevertheless, there are instances when we come across a list or array containing values that require squaring collectively. Let’s explore a pair of potential methods for achieving this.

### Square With List Comprehension

A method available to square a sequence of values involves employing a list comprehension. These operations are streamlined and necessitate only minimal code. The following illustrates how a list comprehension can execute squaring for each value within a list:

```nums = [
4, 9, 14, 6, 2,
43, 7, 82
]
# Create list with each value squared
squared = [num ** 2 for num in nums]

print("Values:\n", nums)
print("Values squared:\n", squared)

# Output:
# Values:
# [4, 9, 14, 6, 2, 43, 7, 82]
# Values squared:
# [16, 81, 196, 36, 4, 1849, 49, 6724]```

If retaining the original values is unnecessary, a list comprehension can directly replace the existing list with squared values. This is accomplished by assigning the outcome of the list comprehension back to the list itself. You need to calculate the square of each element in the ‘numbers’ list, and update the original list with these squared values. For example:

```nums = [
4, 9, 14, 6, 2,
43, 7, 82
]
# Create list with each value squared
numbers = [num ** 2 for num in nums]

print("Values squared:\n", nums)

# Output:
# Values squared:
# [4, 9, 14, 6, 2, 43, 7, 82]```

If retaining the original values is unnecessary, a list comprehension can directly replace the existing list with squared values. This is accomplished by assigning the outcome of the list comprehension back to the list itself. You need to calculate the square of each element in the ‘numbers’ list, and update the original list with these squared values. For example:

```nums = [
4, 9, 14, 6, 2,
43, 7, 82
]
# Create list with each value squared
squared = []
for num in nums:
squared.append(num ** 2)

print("Values:\n", nums)
print("Values squared:\n", squared)

# Output:
# Values:
# [4, 9, 14, 6, 2, 43, 7, 82]
# Values squared:
# [16, 81, 196, 36, 4, 1849, 49, 6724]```

In the prior approach, we retained squared values within a new list. However, if preserving the initial list is unnecessary, it’s possible to directly replace it with squared values. When utilizing a for loop for this purpose, Python’s enumerate() function becomes particularly useful, allowing us to access both the value and its index. You need to Iterate over the original ‘numbers’ list, squaring each individual number and subsequently updating the original list with these squared values. For instance:

```nums = [
4, 9, 14, 6, 2,
43, 7, 82
]
for index, num in enumerate(nums):
nums[index] = num ** 2

print("Values squared:\n", nums)

# Output:
# Values squared:
# [16, 81, 196, 36, 4, 1849, 49, 6724]```

# Discovering Lasso Regression Python

Lasso regression stands as a noteworthy machine learning algorithm that not only facilitates linear regression but also effectively curtails the array of features incorporated within the model.

Also recognized as L1-norm regularization, Lasso regression integrates a penalty term into the cost function, proportionally linked to the cumulative absolute coefficients. This deliberate inclusion prompts the model to singularly favor the utmost crucial attributes while relegating the coefficients of lesser significance to a value of zero. Lasso regression operates as an augmentation of linear regression, introducing a regularization parameter multiplied by the summation of absolute weight values, which is subsequently amalgamated into the loss function of the conventional least squares technique.

In comparison to alternative regularization approaches like Ridge regression, which employs L2 regularization, Lasso regression claims an edge in yielding sparse solutions—instances where only a subset of features is embraced by the model. This innate trait renders Lasso regression a favored avenue for endeavors involving feature selection and the scrutiny of data entrenched within high-dimensional spaces.

However, a drawback associated with Lasso regression materializes in scenarios where the number of features eclipses the number of samples. The mechanism employed by Lasso regression to nullify certain attributes by relegating their coefficients to zero can be counterproductive when dealing with an expansive set of features.

## What is Lasso?

Lasso stands for least absolute shrinkage and selection operator. Pay attention to the words, “least absolute shrinkage” and “selection”. We will refer to it shortly.
Lasso regression is used in machine learning to prevent overfitting. It is also used to select features by setting coefficients to zero.

## What is Regression?

Regression, when it comes to statistics and machine learning, is a way to figure out how things are connected. You take some things that might affect something else, and you try to find out how much they actually do. The main point of this kind of math is to see how changes in one thing are connected to changes in another. It’s like trying to predict what will happen based on certain factors.

The thing you’re trying to figure out or predict is called the “outcome.” And the factors that might be influencing it are called “independent variables.” This math helps you put numbers on how these things are linked.

• There are different methods to do this math, but two big ones are:
Linear Regression: This is like drawing a straight line that fits the data. The idea is to find the best line that gets really close to the real points. A problem with linear regression is that estimated coefficients of the model can become large, making the model sensitive to inputs and possibly unstable.
• Logistic Regression: This sounds complicated, but it’s just used to tell whether something is one thing or another. Like, if you have data about whether it’s sunny or rainy and you want to predict the weather for tomorrow.

Other ways to do this math include using curved lines (polynomial regression), adding some rules to avoid getting too crazy (ridge and lasso regression), and even fancier methods like support vector regression and random forest regression.

In simple terms, regression is a basic tool to understand how things are linked, make guesses about the future, and get some smart insights from numbers.

## Lasso Regression Python Example

In Python, Lasso regression can be executed through the employment of the Lasso class found within the sklearn.linear_model library.

### Lasso Regression in Python Using Sklearn Library

```#imports necessary libraries from scikit-learn
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.linear_model import Lasso
from sklearn.metrics import mean_squared_error
from sklearn.preprocessing import StandardScaler

# Split the data into training and test sets
X_train_orig, X_test_orig, y_train_orig, y_test_orig = train_test_split(diabetes_data.data, diabetes_data.target, test_size=0.3, random_state=42)

# Scale the data using StandardScaler
data_scaler = StandardScaler()
X_train_scaled = data_scaler.fit_transform(X_train_orig)
X_test_scaled = data_scaler.transform(X_test_orig)

# Fit Lasso regression model
lasso_reg = Lasso(alpha=0.1)
lasso_reg.fit(X_train_scaled, y_train_orig)

# Evaluate model performance on the test set
y_pred = lasso_reg.predict(X_test_scaled)

# Model Score
model_score = lasso_reg.score(X_test_scaled, y_test_orig)
print("Model Score: ", model_score)

# Lasso Coefficients
lasso_coefficients = lasso_reg.coef_
```

Here, the code imports various modules from scikit-learn: datasets for loading datasets, train_test_split for splitting data into training and test sets, Lasso for creating a Lasso regression model, mean_squared_error for calculating the mean squared error, and StandardScaler for data scaling. The code loads the diabetes dataset using scikit-learn’s built-in load_diabetes() function. Then we create a StandardScaler instance to standardize the feature data. The training features (X_train_orig) are fitted to the scaler to compute mean and standard deviation, and then both training and test features are scaled using these statistics. The code predicts the target values using the trained Lasso model on the scaled test features (X_test_scaled). The model’s performance is evaluated using the .score() method, which calculates the coefficient of determination (R^2) between predicted and true values. The score is printed to the console.
The code prints the R-squared model score to assess the performance. The Lasso coefficients (regression coefficients) are stored in the lasso_coefficients variable.

So here we showed how to load a dataset, split it into training and test sets, scale the features, train a Lasso regression model, evaluate its performance, and extract the model’s coefficients using scikit-learn.

### Making Lasso Regression Using Numpy Library and CSV Files

Let’s introduce the housing dataset. The housing dataset is a standard machine learning dataset comprising 506 rows of data with 13 numerical input variables and a numerical target variable.

Using a test harness of repeated stratified 10-fold cross-validation with three repeats, a naive model can achieve a mean absolute error (MAE) of about 6.6. A top-performing model can achieve a MAE on this same test harness of about 1.9. This provides the bounds of expected performance on this dataset.
Mean Absolute Error (MAE) is a common metric used to measure the accuracy of a predictive model, particularly in regression tasks.

The dataset involves predicting the house price given details of the house suburb in the American city of Boston.

Here is an example:

```# Import necessary libraries
import pandas as pd
import matplotlib.pyplot as plt

# Display the shape of the dataset
print(example_data.shape)

# Display the first few rows of the dataset

#Output:
#(475, 14)
# 0 1 2 3 4 5 ... 8 9 10 11 12 13
#0 0.01 18.0 2.31 0 0.54 6.58 ... 1 296.0 15.3 396.90 4.98 24.0
#1 0.03 0.0 7.07 0 0.47 6.42 ... 2 242.0 17.8 396.90 9.14 21.6
#2 0.03 0.0 7.07 0 0.47 7.18 ... 2 242.0 17.8 392.83 4.03 34.7
#3 0.03 0.0 2.18 0 0.46 7.00 ... 3 222.0 18.7 394.63 2.94 33.4
#4 0.07 0.0 2.18 0 0.46 7.15 ... 3 222.0 18.7 396.90 5.33 36.2
```

The example downloads and loads the dataset as a Pandas DataFrame and summarizes the shape of the dataset and the first five rows of data.

Next we provide an implementation of the Lasso penalized regression algorithm via the Lasso class and scikit-learn Python machine learning library.

We can evaluate the Lasso Regression model on the housing dataset using repeated 10-fold cross-validation and report the average mean absolute error (MAE) on the dataset.

```# Import necessary libraries
import numpy as np
import pandas as pd
from sklearn.model_selection import cross_val_score, RepeatedKFold
from sklearn.linear_model import Lasso

data = data_df.values
X_features, y_target = data[:, :-1], data[:, -1]

# Define the Lasso regression model
lasso_model = Lasso(alpha=1.0)

# Define the cross-validation strategy
cv_strategy = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)

# Evaluate the model using cross-validation
neg_mean_absolute_errors = cross_val_score(lasso_model, X_features, y_target, scoring='neg_mean_absolute_error', cv=cv_strategy, n_jobs=-1)

# Convert negative errors to positive
pos_mean_absolute_errors = np.absolute(neg_mean_absolute_errors)

# Calculate and print mean and standard deviation of positive MAE scores
mean_mae = np.mean(pos_mean_absolute_errors)
std_mae = np.std(pos_mean_absolute_errors)
print('Mean Absolute Error (MAE): %.3f (%.3f)' % (mean_mae, std_mae))

#Output:
#Mean Absolute Error (MAE): 3.711 (0.549)
```

Confusingly, the lambda term can be configured via the “alpha” argument when defining the class. The default value is 1.0 or a full penalty.

Running the example evaluates the Lasso Regression algorithm on the dataset and reports the average MAE across the three repeats of 10-fold cross-validation.

Your specific results may vary given the stochastic nature of the learning algorithm. Consider running the example a few times.

In this case, we can see that the model achieved a MAE of about 3.711.

## Lasso Regression Prediction in Python

We may decide to use the Lasso Regression as our final model and make predictions on new data.
This can be achieved by fitting the model on all available data and calling the predict() function, passing in a new row of data.

We can demonstrate this with a complete example, listed below.

```# Import necessary libraries
from sklearn.linear_model import Lasso as LassoRegression

# Access the dataset from its digital realm
dataset = data_table.values
input_data, target = dataset[:, :-1], dataset[:, -1]

# Craft the Lasso of Regression
regressor = LassoRegression(alpha=1.0)

# Infuse the model with insights from the dataset
regressor.fit(input_data, target)

# Define new data for a prophecy
new_sample = [0.00632, 18.00, 2.310, 0, 0.5380, 6.5750, 65.20, 4.0900, 1, 296.0, 15.30, 396.90, 4.98]

# Evoke the predictive powers
prediction = regressor.predict([new_sample])

# Reveal the outcome of the prediction
print('Oracle Predicts: %.3f' % prediction)

#Output:
#Oracle Predicts: 30.998```

Running the example fits the model and makes a prediction for the new rows of data.

Your specific results may vary given the stochastic nature of the learning algorithm. Try running the example a few times.

Next, we can look at configuring the model hyperparameters.

## Changing Lasso Hyperparameters in Python

We are aware that the alpha hyperparameter’s default value is set at 1.0. However, it is considered a prudent approach to experiment with an array of diverse setups and unveil the configuration that optimally suits our dataset.

### Changing Config by GridSearchCV in Python

One approach would be to gird search alpha values from perhaps 1e-5 to 100 on a log-10 scale and discover what works best for a dataset. Another approach would be to test values between 0.0 and 1.0 with a grid separation of 0.01. The example below demonstrates this using the GridSearchCV class with a grid of values we have defined.

```# Perform a grand quest for optimal hyperparameters with Lasso Regression
from numpy import arange as create_range
from pandas import read_csv as acquire_data
from sklearn.model_selection import GridSearchCV
from sklearn.model_selection import RepeatedKFold
from sklearn.linear_model import Lasso as TheLasso

# Unearth the dataset from its digital realm
data_treasures = data_scroll.values
X_marks_the_features, y_guards_the_target = data_treasures[:, :-1], data_treasures[:, -1]

# Summon the Lasso of Modeling
model_of_choice = TheLasso()

# For the art of evaluation, a method is designated
folded_kingdoms = RepeatedKFold(n_splits=10, n_repeats=3, random_state=1)

# Crafting a grid of possibilities
hyperparam_grid = dict()
hyperparam_grid['alpha'] = create_range(0, 1, 0.01)

# Initiating the grand hunt
hyperparam_hunt = GridSearchCV(model_of_choice, hyperparam_grid, scoring='neg_mean_absolute_error', cv=folded_kingdoms, n_jobs=-1)

# Commencing the search across realms
results_of_quest = hyperparam_hunt.fit(X_marks_the_features, y_guards_the_target)

# Unveiling the secrets
print('Mystical MAE: %.3f' % results_of_quest.best_score_)
print('Optimal Configurations: %s' % results_of_quest.best_params_)

#Output:
#Mystical MAE: -3.379
#Optimal Configurations: {'alpha': 0.01}```

In this case, we can see that we achieved slightly better results than the default 3.379 vs. 3.711. Ignore the sign; the library makes the MAE negative for optimization purposes.
We can see that the model assigned an alpha weight of 0.01 to the penalty.

### Changing Alpha Using LassoCV Class in Python

The scikit-learn library also equips us with an integrated version of the algorithm that effortlessly seeks optimal hyperparameters through the LassoCV class.

To employ this class, the model is seamlessly merged with the training dataset in the conventional manner. During this union, the hyperparameters undergo a clandestine metamorphosis, orchestrated by the enigmatic currents of training. The fit model can then be used to make a prediction.

As a default course of action, the LassoCV class embarks on an exhaustive pilgrimage, exploring the model’s efficacy across a collection of 100 alpha values. We can change this to a grid of values between 0 and 1 with a separation of 0.01 as we did in the previous example by setting the “alphas” argument.

The example below demonstrates this.

```# Utilize the Lasso Regression algorithm with automatic configuration
from numpy import arange as create_sequence
from sklearn.linear_model import LassoCV as AutoLasso
from sklearn.model_selection import RepeatedKFold as CyclicFolds

# Obtain the dataset from its digital repository
data_store = data_table.values
input_data, target_values = data_store[:, :-1], data_store[:, -1]

# Determine the model evaluation approach
iterating_folds = CyclicFolds(n_splits=10, n_repeats=3, random_state=1)

auto_reg_model = AutoLasso(alphas=create_sequence(0, 1, 0.01), cv=iterating_folds, n_jobs=-1)

auto_reg_model.fit(input_data, target_values)

print('Optimal alpha: %f' % auto_reg_model.alpha_)

# Output:
# Optimal alpha: 0.000000```

Executing the illustration involves training the model and unearthing the hyperparameters that yield the finest outcomes through the utilization of cross-validation.
Your specific results may vary given the stochastic nature of the learning algorithm. Try running the example a few times.
In this case, we can see that the model chose the hyperparameter of alpha=0.0. This is different from what we found via our manual grid search, perhaps due to the systematic way in which configurations were searched or selected.

# What Is End To End Testing?

End-to-end testing, or E2E testing for short, is a method of careful testing by software checking the whole process of application, from start to finish. This technique simulates realistic user cases and uses actual data to test the smooth operation of all parts and guarantee the soft app works perfectly in real-life conditions.

Suppose we want to test an e-commerce website thoroughly. We would go through the whole buying process, from choosing a product, putting items in the cart, filling in payment information, placing the order, and getting an email with approval. Also, checking of various website parts is also needed on how they work well together, such as a cart, payments, and email notifications.

End to end testing is essential as it can detect probable mistakes that might occur during the integration of all components. Such a method facilitates ensuring the dependability and quality of a system before it is deployed, making it more resilient. Furthermore, it reveals how the application performs from an end user’s viewpoint, resulting in a thorough assessment of the software’s quality.

## What Is End-To-End Testing In Soft Checking?

End to end tests are very important in any testing of the soft as they cover the whole application, emulating real-life prognosis of a user with actual data. E2E testing guarantees proper work of application and satisfaction of user needs.

This stage is the last one in the testing of software. During it, all elements of a code and all soft characteristics are tested as an entire system. It tests the obvious behavior of components and ensures the correct work of the soft app in conditions of reality.

End-to-end tests play a crucial role in identifying potential errors that may arise during the integration of all components. This guarantees the system’s stability and establishes quality standards before deployment. Additionally, it provides insights into the application’s performance from the end user’s perspective, offering a comprehensive evaluation of the full quality of a soft.

## Examples of End 2 End Testing

End to end solution is a holistic way of software testing that covers the verification of the whole soft system, as well as its connection with external interfaces. By mimicking situations in the real world, it ensures the dependability of the system by finding and fixing probable problems or errors before deployment.
Here you can estimate certain end-to-end testing with an example:
• E-commerce website testing: Simulating user order placement, payment processing, and verifying order fulfillment and delivery.
• Testing of Voice recording app: Simulating user audio recording, downloading the file, and integrating it with email to send recorded audio.
• Gmail testing: Simulating user interaction, including login, composing and sending an email, verifying successful delivery, and logout.

#### Application

E-commerce website

Voice recording app

Gmail

#### Test Scenario

Order placement and delivery

Audio recording and sharing

Email sending and receiving

#### Test Steps

1. Simulate a user’s order placement
2. Simulate payment processing
3. Verify the correct fulfillment and delivery of the order
1. Simulate a user’s audio recording ranging from one second to five minutes
3. Integrate with an email app to send the recorded audio files
1. Launch a browser
3. Compose and send an email
4. Verify successful delivery to the recipient
5. Log out from the app

## How End To End Testing Differs From Integration Tests?

Integration tests and E2E differ from each other completely, but both check the comprehensive operation of all system components. E2E testing focuses on the entire application, based on the experience of a user, but integration tests are aimed at checking some components as a unit and focus on the way of their communication with foreign systems.

End-to-end testing as a rule is performed when the development process is finished, when integration tests start at the beginning of testing. One and another test are important in making sure complex systems are dependable and robust.

Here’s a comparison table to estimate end to end testing vs integration testing:

Scope

Objective

Testing Focus

Test Environment

Coverage of testing

Timing

Dependencies

Test Data

Defect Identification

Importance

Involvement

#### End-to-End Testing

Validates the entire soft system

Properly ensures functions of a system in real-life prognoses

Simulates scenarios and flows of a user in real-world conditions

Replicates real-world conditions and external interfaces

Covers well the whole application flow

Conducted towards the later stages of cycle of the soft development

Requires fully developed and integrated soft system

Uses realistic and representative data

Identifies issues across the entire system

Detects system-level issues, and guarantees overall system stability

Involves multiple teams and stakeholders

#### Integration Testing

Verifies the relationship between particular modules

Validates the different modules/components integration

Concentrates on module-to-module interactions

Focuses on the interaction of limited components

Specific coverage of module interactions

It can be made during the whole process if development

It is possible to conduct them on individual modules in isolation

May involve test data specific to module integration

Identifies issues related to module interactions

Verifies module interactions and interface correctness

Typically involves developers and testers

How integration testing essentially differs from end-to-end solutions:

Focus: Integration tests ensure the functionality of components personally and together, but E2E testing evaluates the whole product from the user’s point of view.

Scope: Integration tests are narrower, targeting specific functionalities or modules with dependencies, while end to end testing is broader, encompassing user processes and prognoses spanning multiple properties or modules.

Environment: It is possible to make integration tests in a simulated or isolated environment, whereas End 2 End tests necessitate a fully functional environment closely resembling the real operational setup.

Speed: Integration tests are usually faster since it involves fewer parts and steps of the process, while end-to-end testing takes longer due to the inclusion of numerous steps, components, and possibly external factors.

Maintenance: Integration tests are easier in maintaining as they are less influenced by design or user interface changes, whereas E2E may require more frequent updates due to its sensitivity to UI or design changes.

## How Is End To End Test Framework Organized?

E2E testing is a complex of software test methods checking the functional and application data flow, covering all subsidiary systems connected to each other from the beginning to the end. It simulates the user’s journey through the app, verifying the seamless operation of built-in components, dependencies, and elements connected to each other.

A wide range of frameworks for end-to-end testing is available and adopted by different technologies and platforms. Some notable examples of major end to end testing frameworks are as follows:

• Protractor
• NightwatchJS
• Cucumber
• Cypress
• Selenium
• WebdriverJS
• Testim
• testRigor
• WebdriverIO

The purpose of these frameworks is to ensure a structured framework of automation tests, ensuring the reliability and manageability of the created tests.

A standard block diagram of an end to end testing framework is depicted below:

## How End To End Testing Plan Can Be Created?

The testing process follows a thorough document called a plan of e2e testing. This document specifies a subject, a reason, a method, and a time to test. It includes information about the team, the tools, the test cases, the test data, the test environment, the performance, the control of defects, and the reporting. It facilitates the organization of the testing process, assigning of roles, and setting up of the required environment.

To perform comprehensive end-to-end testing plan the following steps are required:

– Make an analysis of the requirements to understand the working principle of application in all aspects.

– Set up a testing environment that corresponds to the requirements and possesses all necessary parts of software and hardware.

– List all primary and secondary systems of the app, and describe their interaction process.

– Write down the expected outcomes and responses for each system and subsystem.

– Choose the testing methods and tools that can best verify these results and responses.

– Make testing cases covering a variety of users, which guarantees complete coverage.

– Run testing cases, check results, and report any defects or issues quickly.

– Repeat the end to end process, with necessary fixes till all defects are recovered, and the app corresponds to the standards of quality.

## Main End To End Solutions

End-to-end testing finds tools and frameworks dedicated to the automation and performance of comprehensive tests for software apps. Such tests, known as end to end tests, assess the functionality and an application execution in its whole workflow in conditions of the real world. They imitate the journeys of users and check the entire system’s behavior, including its sub-systems and dependencies.

We would like to provide some notable end-to-end solutions:

• Autify: A cloud-based platform that facilitates cross-platform testing across diverse devices and operating systems.
• BugBug: A tool based on a browser enabling agile teams to create, edit, and make automatic testing that does not contain coding, with executing a function of end to end testing automation
• Head spin: The platform offers secure scaling of testing work and provides an understanding of the performance, quality, and experience of users.
• Nightwatch: A flexible framework supporting custom commands, assertions, and plugin implementation.
• Mabl: A tool utilizing AI to automate test creation, execution, and maintenance.
• Avo Assure: This tool assists in visualizing workflows, monitors testing cases, and generates reports of tests.
• Smart Bear: A suite of tools covering various testing aspects such as tests of API, UI tests, performance tests, and test
• TestRigor: The tool enables the creation of robust and stable end-to-end tests using plain English.
• Selenium: A widely adopted open-source framework supporting multiple browsers, scripts, and platforms.
• Cypress: The framework based on JavaScript simplifies web application testing by operating directly in the browser.

These end-to-end testing methods ensure distinct characteristics, pros, and cons, allowing software projects to choose based on their certain needs and requirements.

## About End To End Testing Best Practices

The best practices of End2end testing are guides or recommendations aimed at ensuring the efficiency of end-to-end tests. These testing methods can estimate the functionality and full performance of an app, and able to replicate conditions of a real-world and validate the behavior of the whole system as well as its secondary systems and dependencies.

We would like to provide you with the key end to end testing best practices:

• Make testing of the full user journey: Cover all possible paths and scenarios that users may encounter, not just the most popular working process of your app.
• Use certain and realistic data: Use data that reflects the actual data users will enter or interact with, including invalid, incomplete, or malicious data.
• Test edge cases: Assess less likely but impactful situations such as unexpected inputs, network failures, timeouts, or exceptions.
• Use various environments in performing tests: Check your app in different browsers, devices, operating systems, and networks used by your users.
• Automate tests: Leverage test automation tools and frameworks to create, execute, and support end-to-end tests, making their execution faster, ensuring broader coverage, and continuousness of testing.
• Document testing cases: Precisely and consistently document test cases using a standard format and language to communicate objectives, steps, expected results, and current results to parties concerned.
• Constantly test: Perform e2e tests regularly, especially after any application changes or during its updating, for detecting and addressing bugs or regressions early.

Provided these best practices are followed, you can enhance this end-to-end process, ensuring satisfaction with your app user’s demands. Implementing these guidelines contributes to delivering a high-quality software product.

# Exploring Sound in Python

Python offers a plethora of possibilities for playing and recording sound. In this tutorial, we’ll guide you through various audio libraries, empowering you to explore the art of sound manipulation.

Diving into the basics, we’ll walk you through straightforward methods for both playing and recording sound. But that’s not all; we’ll also introduce you to advanced libraries that unlock additional functionalities, allowing you to wield the power of sound with just a few extra lines of code.

So, let’s embark on this exciting journey of Python audio programming, where creativity knows no bounds, and sound becomes your canvas! Get ready to immerse yourself in the world of music and audio with Python as your trusted companion. Let’s begin!

## How to Play Audio Files?

In this comprehensive guide, we will explore a variety of Python libraries that cater to your audio playing needs. Whether you’re handling MP3s, WAV files, or NumPy arrays, these libraries will empower you to delve into the world of sound manipulation with ease.

Let’s kick off with the ever-simple playsound package, perfect for straightforward WAV or MP3 file playback. Its minimalist approach makes it a breeze to use for basic audio needs.

For a step up in versatility, consider simple audio. This gem not only handles WAV files and NumPy arrays but also offers convenient options to check the playback status of your files, giving you more control over your audio experience.

Windows users will find Winsound particularly useful, allowing WAV file playback and even speaker beeping, though it’s exclusive to the Windows platform.

For cross-platform capabilities, Python-sounddevice and PyAudio come to the rescue, providing bindings for the powerful PortAudio library. Both are excellent choices for playing WAV files across different operating systems.

Last but not least, we have pydub, which, when combined with Pyaudio and FFmpeg, opens the door to an extensive range of audio formats. With just a few lines of code, you can revel in the richness of audio possibilities.

Now you have a spectrum of options at your disposal, each library offering its unique strengths. So, let’s dive in.

## What Is a Playsound Module?

Get ready to elevate your Python audio experience with the playsound module. This is a cross-platform module that opens the gateway to audio file playback.
playsound() is the only function that is contained in this library.
playsound harmonizes with both Python 2 and Python 3, ensuring a seamless experience across different versions. In the documentation, it is written that this library works well with mp3 and wav files, but it is also possible to use for other file formats.

The command to install playsound package

`pip install playsound`

playsound() function have one or two arguments and looks like this:

`playsound("/filepath/song.mp3")`

or

`playsound("/filepath/song.mp3" , 0)`

where “/filepath/song.mp3” stands for a local file path or a URL and the second argument stands for block(default True) that can also be set to False for running asynchronously.

### Playsound in Python for MP3 Format

```#import playsound module
from playsound import playsound

playsound("/filepath/song.mp3")```

### Playsound in Python for WAV Format

There is no difference between code that is used to play MP3 or WAV format.

```#import playsound module
from playsound import playsound

playsound("/filepath/song.wav")```

## What Is a Simpleaudio Library?

Simpleaudio stands out as a versatile and cross-platform library, offering seamless playback of mono and stereo WAV files without any dependencies. Employing the provided code snippet allows users to effortlessly play a WAV file, ensuring the script waits until the file completes playback before terminating.

```import simpleaudio as sa

file = 'song.wav'
wave_obj = sa.WaveObject.from_wave_file(file)
play_obj = wave_obj.play()
play_obj.wait_done()```

Delving into the intricacies of WAV files, they encompass a stream of bits capturing the raw audio data alongside metadata in the RIFF (Resource Interchange File Format) format.
In the realm of CD recordings, the gold standard involves storing each audio sample, which corresponds to an individual audio datapoint relating to air pressure, as a 16-bit value at a rate of 44100 samples per second.

To optimize file size, certain recordings, such as those containing human speech, can be suitable with a lower sampling rate, for instance, 8000 samples per second. However, this does come at the cost of potentially compromised representation for higher sound frequencies.

Both bytes objects and NumPy arrays encompass a sequence of data points, facilitating sound playback at a specified sample rate. When working with bytes objects, each sample is stored as a pair of 8-bit values, while NumPy arrays employ 16-bit values to represent individual samples.

An essential distinction between these data types is their mutability: bytes objects are immutable, whereas NumPy arrays are mutable, rendering the latter ideal for generating sounds and engaging in more intricate signal processing tasks.

The brilliance of simpleaudio lies in its ability to play NumPy and Python arrays and bytes objects through the utilization of simpleaudio.play_buffer(). Before running the ensuing example, ensure the presence of NumPy on your system, and install it effortlessly by executing pip install NumPy from your console.

```#import modules
import numpy as np
import simpleaudio as sa

seconds = 3 # Note duration
frequency = 440 # Note will be 440 Hz
sample_rate = 44100 # samples per second

t = np.linspace(0, seconds, int(sample_rate * seconds), False)

# 440 Hz sine wave
wave = np.sin( 2 * np.pi * frequency * t)

# Convert to 16-bit data
audio = (wave * 32767).astype(np.int16)

# Start playback
play_obj = sa.play_buffer(audio, num_channels=1, bytes_per_sample=2, sample_rate=sample_rate)

play_obj.wait_done()```

Feel free to explore the endless possibilities unlocked by simpleaudio, making audio playback and manipulation an enjoyable and seamless experience across different platforms.

## Winsound Library and How It Works

Introducing winsound, a versatile module designed exclusively for Windows users, allowing playback of ‘.wav’ music files directly from your system. For those on different operating systems, fret not, as the ‘PlaySound’ module comes to the rescue.

The best part? No installation is required! Winsound module is preinstalled and readily available.

Keep in mind that Winsound is limited to playing “.wav” files only. However, if you have other file formats you’d like to play, you can turn to the PlaySound module to handle those for you.

winsound.Beep(frequency, duration) function allows you to beep your speakers.

The first parameter, “frequency,” dictates the pitch of the sound and is measured in hertz (Hz), ranging from 37 to 32,767. This gives you the flexibility to create different tones based on your needs. Next, the “duration” parameter comes into play, allowing you to control how long the sound persists in milliseconds.

For example, you can beep a 250 Hz tone for 100 milliseconds with the following code:

```import winsound

#beep sound
winsound.Beep(250,100)```

In addition to using the Winsound module, another method at your disposal is PlaySound(). This function also requires two arguments: the file path of the sound you wish to play and a flag that allows you to apply various conditions to the audio playback. For example, you can use SND_LOOP to create a continuous loop of the sound or SND_NOSTOP to prevent interruptions during playback.

```import winsound

winsound.PlaySound("/filepath/song.wav", window.SND_LOOP)```

Also, there is MessageBeep() function that allows you to play different types of beeps based on the parameter you pass. In this example, we’ll use MB_OK to play the OK sound.

Here’s an example:

```import winsound

winsound.MessageBeep(winsound.MB_OK)```

## Do Developers Need Python-Sounddevice?

Python-sounddevice is a Python library that empowers developers to work with audio streams and devices effortlessly. Whether you want to record audio from a microphone, play sound through speakers, process real-time audio data, or simply manipulate audio files, Python-sounddevice provides an intuitive interface to accomplish these tasks with ease.

One of the key features that sets Python-sounddevice apart is its ability to access audio devices directly, bypassing the need for external programs or dependencies. This direct access to the sound hardware enables low-latency audio I/O operations, making it suitable for real-time audio applications like audio synthesis, live audio processing, and interactive audio programs.

To enable the playback of WAV files and open them as NumPy arrays, you must have NumPy and soundfile installed on your system.

```import sounddevice as sd
import numpy as np

# Create a sine wave for demonstration
frequency = 440 # note frequency in Hz
seconds = 3 # seconds
t = np.linspace(0, seconds, int(duration * 44100), endpoint=False)
audio = 0.5 * np.sin(2 * np.pi * frequency * t)

# Play the audio
sd.play(audio, samplerate=44100)
sd.wait()```

### Pydub

While pydub has the capability to open and save WAV files independently, to experience audio playback, it’s essential to have an audio playback package installed. The preferred choice is simpleaudio, offering robust functionality, though PyAudio, FFplay, and AVPlay stand as viable alternative options.

```from pydub import AudioSegment
import pyaudio

audio = AudioSegment.from_wav('song.wav')
play(audio)```

For seamless playback of various audio formats, like MP3 files, it’s essential to have either FFmpeg or Libav installed on your system.

By utilizing FFmpeg-python, you gain access to FFmpeg bindings, which can be installed via pip:

`pip install ffmpeg-python`

Once FFmpeg is set up, making playback for an MP3 file necessitates just a minor modification to our previous code snippet:

```from pydub import AudioSegment
from pydub.playback import play

audio = AudioSegment.from_mp3('song.mp3')
play(audio)```

With the help of the AudioSegment.from_file(filename, filetype) method, you have the flexibility to play audio files of any format supported by FFmpeg. For instance, you can effortlessly play a WMA file using the following code snippet:

`audio = AudioSegment.from_file('sound.wma', 'wma')`

Expanding its capabilities beyond sound playback, Pydub offers a plethora of functionalities. You can easily save audio in various file formats, slice audio segments, calculate audio file lengths, apply fade-in and fade-out effects, and even add crossfades between tracks.

A particularly interesting feature is AudioSegment.reverse(), which generates a mirrored copy of the AudioSegment, playing the audio backward.

### PyAudio

Harnessing the power of PyAudio, you gain access to seamless Python bindings for PortAudio v19, a cross-platform audio I/O library. PyAudio empowers you to effortlessly leverage Python for audio playback and recording across multiple platforms, including GNU/Linux, Microsoft Windows, and Apple macOS.

```import pyaudio
import wave

file = 'song.wav'

# chunk size
chunk = 1024

wf = wave.open(file, 'rb')

p = pyaudio.PyAudio()

# Open a .Stream object
stream = p.open(format = p.get_format_from_width(wf.getsampwidth()),
channels = wf.getnchannels(),
rate = wf.getframerate(),
output = True)

# Play the sound
while data != '':
stream.write(data)

# Close and terminate the stream
stream.close()
p.terminate()```

You may have noticed that working with sounds using PyAudio can be more intricate compared to other libraries you’ve encountered earlier. As a result, if your goal is to simply play a sound effect in your Python application, PyAudio might not be your immediate choice.

However, PyAudio offers the advantage of providing finer control at a low level, allowing you to access and modify parameters for both input and output devices, as well as check your CPU load and input/output latency.

Moreover, PyAudio empowers you to interact with audio using callback mode, wherein a callback function is triggered when there is a demand for new data during playback or when new data is available for recording. These capabilities make PyAudio an excellent choice when your audio requirements extend beyond basic playback functionality.

## How to Record Audio In Python?

In the realm of audio recording with Python, you have two prominent libraries at your disposal: python-sounddevice and PyAudio. The former facilitates audio recording into NumPy arrays, while the latter accomplishes the same task with bytes objects. Leveraging the capabilities of the SciPy and wave libraries, you can efficiently store these recorded data as WAV files for further use.

```import sounddevice as sd
from scipy.io.wavfile import write

seconds = 3 # Duration of recording
sample_rate= 44100 # Sample rate

recording = sd.rec(int(seconds * sample_rate), samplerate=sample_rate, channels=2)
sd.wait()
write('output.wav', sample_rate, recording)```

### PyAudio

To initiate audio recording, an alternative approach involves writing to the .Stream:

```import pyaudio
import wave

chunk = 1024
format = pyaudio.paInt16
channels = 2
sample_rate = 44100
duration = 5
output = "recorded_audio.wav"

p = pyaudio.PyAudio()

stream = p.open(format=format,
channels=channels,
rate=sample_rate,
input=True,
frames_per_buffer=chunk)

print("Recording...")

frames = []

# Store data
for i in range(0, int(sample_rate / chunk * duration)):
frames.append(data)

# Stop and close the stream
stream.stop_stream()
stream.close()
p.terminate()

# Save the recorded data
wf = wave.open(output, 'wb')
wf.setnchannels(channels)
wf.setsampwidth(p.get_sample_size(format))
wf.setframerate(sample_rate)
wf.writeframes(b''.join(frames))
wf.close()```

## How to Save and Convert Audio in Python?

In a previous instance, it was demonstrated how the scipy.io.wavfile module proves useful for saving NumPy arrays as WAV files. However, there’s more to explore with the Wavio module, as it facilitates seamless conversion between WAV files and NumPy arrays. But what if you wish to store your audio in alternative formats? Fear not, for both Pydub and soundfile libraries come to your rescue! These powerful tools enable you to effortlessly read and write an extensive range of popular file formats, opening up new possibilities for your audio processing endeavors.

### Wavio

Relying on the NumPy library, this module offers a seamless way to read WAV files as NumPy arrays while also allowing you to save NumPy arrays as WAV files.
When the time comes to store a NumPy array as a WAV file, you’ll find the function wavio.write() at your disposal. This handy feature ensures a smooth and efficient conversion process, giving you the flexibility to work with audio data in your desired format.

```import numpy as np
import wavio

sample_rate = 44100
seconds = 5
frequency = 440
samples = np.arange(sample_rate * duration) / sample_rate
audio = np.sin(2 * np.pi * frequency * samples)

output = "output.wav"
wavio.write(output, audio, sample_rate, sampwidth=2)```

### Soundfile

Soundfile is a Python library that enables the reading and writing of various file formats, leveraging the capabilities of libsndfile. While it lacks audio playback functionality, it excels at audio conversion between formats like FLAC, AIFF, and some more uncommon audio types. For instance, if you wish to convert a WAV file to FLAC, the following code snippet can be employed:

```import soundfile as sf

# Extract data from file
# Save as FLAC file
sf.write('song.flac', data, sample_rate)```

### Pydub

Pydub offers extensive support for audio file formats, allowing you to save your audio in any format that is supported by FFmpeg. This encompasses a wide range of audio types commonly encountered in your everyday activities. For instance, the following code snippet demonstrates how you can effortlessly convert a WAV file to the popular MP3 format:

```from pydub import AudioSegment

audio = AudioSegment.from_wav('song.wav')

audio.export('song.mp3', format='mp3')```

# What is UnicodeDecodeError in Python?

When you work with your projects it is common to encounter UnicodeDecodeErorrs. They appear when you work with characters and you try to encode and decode them. To simply understand what it is, it appears when string cannot be properly decoded using your specific encoding scheme.

## Determine the Encoding

To start understanding what encoding you have used in your code, you can use these samples. The code begins by importing the Chardet library, which is a Python library for automatic character encoding detection. Inside the function, the file is opened in binary mode (‘rb’) using a with the statement, ensuring that the file is properly closed after reading. The chardet.detect() function is then called, passing the raw_data as an argument. This function analyzes the binary data and attempts to determine the most likely character encoding:

```import chardet

def detect_encoding(file_path):
with open(file_path, 'rb') as f:
result = chardet.detect(raw_data)
encoding = result['encoding']
return encoding

file_path = 'path/to/your/file.txt'
encoding = detect_encoding(file_path)
print(f"The file is encoded in {encoding}.")```

Also here is another way to determine this:

```import subprocess
def detect_encoding(file_path):process = subprocess.Popen(['file', '--mime', '-b', file_path], stdout=subprocess.PIPE)output, _ = process.communicate()mime_info = output.decode().strip()encoding = mime_info.split('charset=')[-1]return encoding
file_path = 'path/to/your/file.txt'encoding = detect_encoding(file_path)print(f"The file is encoded in {encoding}.")```

In this code, the subprocess.Popen function is used to execute the file command with the –mime flag to retrieve the MIME type of the file. The output is then parsed to extract the encoding information.

## Getting a “UnicodeDecodeError: ‘utf-8’ Codec Can’t Decode Byte”

Why am I getting a “UnicodeDecodeError: ‘utf-8’ codec can’t decode byte” error when decoding a byte string?

`byte_string = b'\xc3\x28'decoded_string = byte_string.decode('utf-8')print(decoded_string)`

So here the error occurs because the byte sequence \xc3\x28 is not a valid UTF-8 encoded character. You can handle this error by using “errors=’replace’” inside decode or provide one of the valid utf-8 single-byte characters or multi-byte characters. For example, the letter ‘A’ (U+0041) is represented by the byte \x41.

```import pandas as pd
data.drop('isin', inplace=True, axis=1)
#Output#UnicodeDecodeError: 'utf-8' codec can't decode byte 0xfc in position 38835```

Here we import pandas to use it for reading csv files. After running it we receive an error. The error occurs as ‘0xfc‘ is ü character (latin small letter u with diaeresis), so we can use encoding=’latin1′ that will fix the issue.

```import pandas as pd
data.drop('isin', inplace=True, axis=1)```

Remember to adapt these codes to your specific use cases and encoding requirements. It can appear when you read or write files, parse CSV or other delimited files, scrape web data or database interactions. Handling UnicodeDecodeError requires understanding the encoding of your data and applying appropriate error-handling strategies to ensure the smooth execution of your code.

## Also About “UnicodeDecodeError: ‘ascii’ Codec Can’t Decode” Error

Such an error can be when you want to use an ASCII codec with non-ASCII characters. Here is an example:

`byte_string = b'\xe9'decoded_string = byte_string.decode('ascii')print(decoded_string)`

The byte sequence \xe9 is not an ASCII character but it is UTF-8, so changing it will resolve an error.

## How to Handle Errors with UnicodeDecodeError?

So you have the situation when you need to handle errors when a programmer will not use utf-8 codec. One approach is to skip the problematic characters or replace them with a placeholder. Here’s an example:

```text = "This is some text with an invalid character: \x80"
try:decoded_text = text.decode('utf-8')print(decoded_text)except UnicodeDecodeError as e:print("Decoding error occurred:")print(e)cleaned_text = text.decode('utf-8', errors='ignore')print("Cleaned text:", cleaned_text)```

There can also be an option when you use instead of “text.decode(‘utf-8’)” the “codecs.decode(text, ‘utf-8′)”, but the lore is the same. If a decoding error occurs, the exception is caught, and the error message is printed. Then, the function is called again with the errors=’ignore’ parameter to decode the text while ignoring any decoding errors. This allows the code to continue execution without raising an exception.

## How to Handle Errors When Processing User Input?

Here let`s see an example of user input:

`user_input = input("Enter a string: ")decoded_string = user_input.decode('utf-8')print(decoded_string)`

You can wrap the code in a try-except block and print the message or make another action like this:

`user_input = input("Enter a string: ")try:decoded_string = user_input.decode('utf-8')print(decoded_string)except UnicodeDecodeError:print("Invalid characters encountered. Please try again.")`

# Pull Requests: A Guide

In version control systems such as git pull requests add the ability to propose changes, introduce new features, and fix bugs in the codebase of projects. In addition to simply presenting the code, facilitating teamwork, and encouraging constructive comprehensive reviews of proposed changes before they are seamlessly merged into the core codebase, pull requests have become an important component of the development process.

The core mechanism of implementation and patching projects involve very simple dispatch which they maintain only in high quality and serve as a gateway to participate in collaborative iteration. A valuable approach helps define and refine the overall implementation strategy, effective review is an aspect that allows experienced professionals to make a holistic assessment through thoughtful reviewers who can suggest ideas for improvement and ensure compliance with the best practices of the team.

## What is a Pull Request?

Pull requests are git functions for development processes used to make updates. In most cases, a merging pull request is used to integrate new functionality or correct an error in the main version, to discuss and approve changes in the project.
DevOps use them in such projects to contribute code to the repository with proposed additions.

If earlier the repository was just a place to store code, then with the appearance of pull requests it became a place to store knowledge about this code. The pull request includes a brief explanation of the reasons for the changes made.

The main advantage is that they help maintain a high level of code quality and can provide feedback on changes made. Key authors or accompanying persons usually act as reviewers, in

### How a Pull Request Should Look Like

Checking pool request is one of the most time-consuming tasks in software development. When creating new functionality, many side nuances may arise: typos, new code may break something in the rest of the code base, unused resources that appeared after refactoring, etc. An ideal git pull request has a small set of characteristics:

1. Small size. Agree that it is quite difficult to check very large pull requests. Especially when you do not fully understand the context of the task. As the number of changes increases, it becomes more and more difficult to stay focused and keep everything in mind. That is, the size must be somehow limited.
2. The static code analyzer does not generate errors. No one wants to check small errors or errors that are easily analyzed by ready-made tools. We can write our own code review rules and use ready-made ones, customize the code writing style and check how it is maintained, etc. Therefore, we need to somehow introduce these errors into the review. If we see new errors, there is no point in checking them yet.
3. You can see the context of the task. We want to see what ticket was worked on and what exactly was done. For this, it would be convenient if we could take a pickup if there is no description in the PR, and add the ticket number and it’s name to the title. Ideally, it would be possible to add screenshots to make the changes visible.
4. “Green” tests. We cover the code with tests, and if changes in the code “break” the tests, it is obvious that such a PR is not yet ready for consideration, since all tests must pass successfully. Therefore, it would be convenient to make it impossible to merge such code.
5. Clear messages about fixation. When we familiarize ourselves with the pull request, it is very easy to trace the sequence of actions of the author when he creates atomic commits, adding understandable messages to them. Ideally, you need to impose the style of writing such messages.
6. Automatic identification of reviewers. If you have a large project, on which several teams are working, it will be convenient to divide the code into areas of responsibility. If you make changes to the repository of a neighboring team, it would be convenient if they could not be rolled back without the approval of that team.
7. Pull request template (checklist). The author must make sure that he has not forgotten anything and completed all the necessary preparatory steps before sending a request for verification. For this, it is convenient to have a list with checkboxes, where the author must mark the actions performed by him. Then the expert will see that the request is ready for analysis.

### How to Make a Pull Request

```git checkout -b newBranch
git commit -a -m "Fixing a ton of bugs"
git push```
You created a new branch and committed changes to it. Then you need to push and apply these changes to the main branch of the project, using the functionality of your repo. Creating a pull request and a merge request is the same thing in GitLab. It’s used in a simplified form when a developer notifies that he has prepared new functionality.

## Pull Requests From GitHub, Bitbucket, Azure

It doesn’t matter where you store the code, Git works with the same commands. Pull requests could be used on a platform like GitHub, GitLab, Bitbucket, or Azure DevOps.

### How to Create a Pull Request Using GitHub

GitHub actions allow you to create automation workflows from a set of separate small tasks that can be connected. To make a pull request, in the GitHub web interface, while on your branch, select the right vertical menu item:

Pull requests -> New pull request -> Edit

New draft pull request GitHub project combines all changes in the code. The feature is already publicly available, in particular, in open GitHub repositories. The developers say that the new function will be especially useful for those whose code cannot yet be evaluated, for example, it is an opportunity for you to mark the processes of work on PR and notify the team immediately after their completion, if you forgot to submit PR it can now be done at the beginning of development.

### How to Merge a Pull Request with GitHub

When you click the “Merge” button on a site, GitHub intentionally creates a merge commit with a link to the pool request so you can easily go back and study the discussion if needed.

### How to Delete a Pull Request Using GitHub

To cancel a GitHub pull request, go to the main page of the repository. Under the name of your repository, click Pull Requests. To delete it, you can click the “Delete branch” button.

### GitHub Close Pull Request

In the “Pull Requests” list, click the item you want to close. At the bottom of the application, under the field for comments, click Close application. If desired, remove the branch. This will keep the list of branches in your repository in order.

### Bitbucket Pull Request

Bitbucket Cloud has a new functionality – pull request experience, that simplifies code review and tracking changes and integrates with Jira there is also a new your work panel that shows issues in Jira and code insights in the cloud.

After adding your feature branch to Bitbucket, you can create a pull request from your account by going to your fork repository and clicking the “Create pull request” button. A form will open in which the repository will be automatically specified as a source.

### Azure DevOps Pull Request

By default, Azure DevOps allows data to be sent directly to the main branch without the need for a pull request. You can change this setting. Go to Repos → Branches and click on the three dots to the right of the branch for which you want to apply pull requests. Next, click on “Branch policies” and select at least one of the proposed policies. This will prevent posting to the selected branch and will require a pull request. The branch will be marked with a blue medal symbol as a hint.