The placement in the company is one of the most delicate processes to manage.
The new employee is in a completely new scenario, the present Team has to restructure,
be flexible and add a good dose of hospitality.

Onboarding and Growth plans

After a lot of hard work, we managed to achieve our goal.


To put a face to the AI? Challenge accepted!!!

Managing Python Versions in Poetry with PyEnv

Events

**Managing Python Versions in Poetry with PyEnv**

I see a lot of confusion on the web how to manage python versions with **pyenv** and dependencies in **poetry**. Here is my quick rundown.

Let’s start with some clarifications.

Python **needs** virtual environments — being also a (dynamic) system component, **never** add libraries to your core system installation. Whatever is packaged from you distribution (Linux) or OS provider (Windows, MacOS) should be OK, anything else is not. Also using virtual environments keeps your requirements in place (within your project) and make clear to additional contributors your work and dependencies.


**Virtual Environments**

**Virtual Environments** ([https://docs.python.org/3/library/venv.html](https://docs.python.org/3/library/venv.html)) are added to a Project by various means — they are a set of directories and links that allow to isolate the installed packages (for the virtual environment) from the installed packages (for the system).

Quickest way to add a virtual environment is to write a line in a terminal:

```python

python -m venv env

```

This will create a virtual environment in the _env_ directory. You can activate it with the usual :

```

source env/bin/activate

```

After activating the environment, any python package installation (which you perform with a _pip install **packagename**_) will end up in _env/_lib/_python.version_/site-packages.

**Poetry**

**Poetry (**[https://python-poetry.org/](https://python-poetry.org/)) is a tool to manage your project, including the capability to manage dependencies, and delivering your created package (if any) to PyPI.

After installation, suggested configuration changes are the following:

```

poetry config virtualenvs.in-project true
poetry config virtualenvs.options.always-copy true
poetry config virtualenvs.prefer-active-python true

```

First will create your virtual environments in the project directory, second will copy instead of symlinking, third will use the currently activated Python version instead of the one used during Poetry Installation.

After this, a **_poetry init _**will result in the following output:

![poetry init](/cms/uploads/1_G_Lj8_EBI_Xk_NQD_Uh_X_Wg_Irh_Fg_e78bdeb53a.png)


This will generate the **pyproject.toml** file containing a description of the Project as defined via the input of the init file.

Finally, a **_poetry shell_** will create the virtual environment in a hidden directory (.venv) with the (eventually) defined additional packages, and activate it. After this, **_poetry shell_** will be used to activate the virtual environment in later sessions.

The **_poetry add packagename_** will install additional packages in the _.venv_ directory.


**Pyenv**

**Pyenv (**[https://github.com/pyenv/pyenv](https://github.com/pyenv/pyenv)) in Linux and MacOS, and pyenv-win ([https://github.com/pyenv-win/pyenv-win](https://github.com/pyenv-win/pyenv-win)) in Windows are the tools used to have multiple versions of Python installed on your system. There are plenty of tutorials on the web, suffice to say that you install the tool and it takes care (being in your path) to create and manage symlinks and various files to manage locally installed Python versions.

Locally installed means that Python gets installed under your home directory ~/.pyenv/… and this directory is referenced from the scripts.

For the Linux users, Pyenv never touches the system python installation. Even when you read about the Global python interpreter, it means the default one for every project.

Just for example, **_pyenv versions _**will show the currently installed (and currently used versions):


![pyenv versions system](/cms/uploads/1_Zz7_WLB_Zv_AH_5_L_Gbp4m_RN_Chg_832b20d30f.png)

 **_pyenv local 3.10_** will install (if not already installed) a 3.10 python version and select it as the default version for the current directory.

![pyenv versions spec](/cms/uploads/1_V_Kq_Oja37_Rzep_G_Gua4k_Kh_Q_910a8a4aa9.png)


**Combining everything**

Managing your project with poetry, allows you to set the python version for the project, but not to manage the installed python versions.

The suggested sequence to correctly manage everything is the following:

```python

pyenv local 3.10 # Set the local version to 3.10
poetry env use $(which python) # set the python version to the current one

```

The first command sets the local version to 3.10. The following one sets the environment used by poetry to the currently selected python version (3.10 via the previous command). Two caveats here: the virtual environment shall not be active, otherwise the python version set will be the virtual environment one, and the python poetry dependency (**tool.poetry.dependencies** stanza in pyproject.toml) should be already correctly set:


![cat pyproject](/cms/uploads/1_7b_L_Pc57w_Er2_GG_7idun_CX_4g_91d173d69a.png)

The result of the _poetry env use_ command will be the following, confirmed by the **_poetry env info_** command:


![poetry env use](/cms/uploads/1_94_Eglt_S9b4_Qz_Z8_BSA_7o_N_Pg_736ca463f7.png)

Python version has been changed, confirmed via the info command. Note that the virtual environment has been recreated.


**Finally, your IDE**

If you use an IDE (I do, PyCharm), you can set the interpreter to a local poetry environment already installed.


**Conclusions**

Even if the pattern here can be confusing and seen as complex, the adoption of virtual environments, poetry and pyenv allows for isolation and capability to detach your project from your local system, allowing for a great deal of flexibility and robustness in Python development.


Phyton.jpg

We were recently commissioned by one of our customers to carry out a very interesting project. As always, we got to work, started our engines and looked for the best way to meet their needs.

The software we developed is a responsive webapp that allows everyone with a good internet connection and a mobile phone to improve their English level by interacting with an avatar managed by an AI.

That's right, through audio-visual interaction with a cartoon-like character, all you need to do is simply turn on your microphone and start talking.

Our character speaks and interacts with its interlocutor just like a real teacher.
At the end of the session, the pupil is entered in a ranking to receive many prizes.

After creating the responsive user interface, the real challenge was to be able to integrate a 3D-character in order for all facial expressions and movements to be managed by a careful process of real-time audio-video synchronisation.

For a flawless user experience, we have also built a do-training system to manage the microphone quality and, in particular, the stability of the Internet connection.

After a lot of hard work, we have succeeded in achieving our goal.

Another happy customer.

We are proud of this achievement and look forward to continuing to work hard to ensure the highest level of quality for our customers.

Now that you know that all of this is possible, imagine what you could do with such a software!!!

And you...
what do you think?"

iStock-1128917945-1280.webp

The placement in the company is one of the most delicate processes to manage.

The new employee is in a completely new scenario, the present Team has to restructure,

be flexible and add a good dose of hospitality.

It is a time of change that forces us to develop an effective path for the employee to acquire new

technical skills, and also be integrated into the already operational team.

The employee in on-boarding, especially a Junior developer who is working for the first time in the IT 

field are propelled in a structured and complex environment(languages, different phases of the 

implementation of the project or simply movement from theory to practice)

How can we translate this stack of papers (or problems - challenges) into a path, in small steps, that

achieve the complete assumption of the role and competences for the newcomer?

In RED we are experimenting with new tools and new ways:

Our Team Leaders verify the Tech Skills of the new entry, build a finalized path to the expansion of 

capabilities, using specific tools and in the planned Review moments.

The "tools" to achieve the shared goals are uploaded on the Jira platform. The new employee, task after 

task and a code line after another, reaches their goal and is ready to be a

RED developer.

We took the big pile and transformed it into a linear and clear path that

favors learning and finds space for constructive feedback at the end of each step of the learning path.

**Onboarding #goals #tools #Jira #we find new solutions # effective insertion # work in progress**

HR manager,
Elisa Mattavelli


onboarding.png

We have developed it with recent technologies such as the Headless CMS model,

we created it to meet our needs, 

we managed it through AWS cloud services, ...

but **above all we did it with the heart**!

Welcome to the new RED Software Systems website,

_The RED Team_

iStock-1249600595-red-cms.jpg

Welcome to the new RED Software Systems website

The new RED website is finally online.