Rust

Rust

Rust is a language designed for writing highly reliable and fast software in a simple way. It can be used from high-level code down to hardware-specific code, and from big irons to tiny devices.
Hans  Marvin

Hans Marvin

1660818674

Rust 1.63: What’s Hot ?

Rust was designed to make it easy to develop fast and safe system-level software. Here’s what’s new.

The unique approach of the Rust programming language results in better code with fewer compromises than C, C++, Go, and the other languages you probably use. It also gets updated regularly, often every month.

Where to download the latest Rust version

If you already have a previous version of Rust installed via rustup, you can access the latest version via the following command:

$ rustup update stable

See more at: https://www.infoworld.com/article/3267624/whats-new-in-the-rust-language.html

#rust

Rust 1.63: What’s Hot ?
Thierry  Perret

Thierry Perret

1660818328

Comment Utiliser Rust Avec Python Facilement Et inversement

Python et Rust occupent des extrémités apparemment opposées du spectre des langages. Python , interprété au moment de l'exécution, offre aux développeurs un environnement de programmation flexible et confortable, mais au prix de la vitesse brute. Rust fournit la vitesse, ainsi que des garanties de sécurité de la mémoire, mais nécessite que vous appreniez un nouveau paradigme pour gérer les opérations de mémoire.

En théorie, ces langages ne devraient pas rivaliser ; ils devraient coopérer. Et dans la pratique, ils le peuvent. Rust peut bénéficier de la facilité d'utilisation de Python, et Python peut bénéficier de la vitesse et de la sécurité de Rust.

Si vous souhaitez utiliser Rust avec Python ou Python avec Rust, vous devez avoir au moins une connaissance passagère des deux langages pour obtenir les meilleurs résultats. Vous devrez également décider laquelle des deux est votre langue principale, car les options pour chaque approche sont très différentes.

Appeler Rust depuis Python avec PyO3

Si Python est votre langage principal, l'intégration avec Rust fonctionne conceptuellement de la même manière que l'intégration de Python avec C. L'implémentation par défaut de Python, écrite en C, utilise des extensions écrites en C ou utilisant une ABI compatible C. Les extensions écrites en Rust qui utilisent le même ABI fonctionneront également, bien que ce ne soit pas automatique - vous devez utiliser des caisses conçues pour fournir des liaisons pour les fonctions Rust à l'API Python C.

Créer des liaisons Rust en Python

Le projet le plus largement reconnu pour créer des liaisons Rust en Python est PyO3 . Il peut être utilisé pour écrire des modules Python dans Rust ou pour intégrer le runtime Python dans un binaire Rust.

PyO3 s'appuie sur un autre projet, Maturin , qui est un outil permettant de créer des caisses Rust avec des emballages et des liaisons Python. Lorsqu'il est installé dans un environnement virtuel Python, Maturin peut être utilisé à partir de la ligne de commande pour initialiser un nouveau projet Rust avec les liaisons Python activées. Le développeur utilise des directives dans le code Rust pour indiquer quelles fonctions Rust exposer à Python et comment exposer l'ensemble du projet Rust à Python en tant que module importable.

Cartographier les types Rust et Python

L'un des aspects utiles de PyO3 est ses mappages entre les types Rust et Python . Les fonctions écrites en Rust peuvent accepter soit des types Python natifs, soit des types Rust convertis à partir de types Python. Par exemple, un objet bytearrayou bytesen Python peut être mappé élégamment à un Vec<u8>en Rust, et un stren Python peut être rendu comme un Rust String.

[ INSCRIVEZ-VOUS MAINTENANT pour CIO 100 : Symposium & Awards Conference, du 15 au 17 août ]

La conversion de Python à Rust entraîne un coût par appel, mais cela vous évite d'avoir à utiliser entièrement les types Python dans le code Rust. Dans le monde Cython, cela s'apparente aux conversions en types C : il y a un coût pour chaque conversion, mais elles apportent des accélérations majeures si votre objectif est le traitement numérique entièrement en C.

Appeler Python depuis Rust avec la caisse de python

Si vous êtes principalement un développeur Rust mais que vous souhaitez utiliser Python dans une application Rust, le cpython crate est un moyen simple de le faire. Le  cpython crate fournit des liaisons Rust à l'interpréteur CPython, qui est le runtime Python le plus courant (ainsi nommé car il est écrit en C).

Les programmes Rust peuvent invoquer l'interpréteur CPython et travailler avec lui, ce qui vous permet de créer et de manipuler des objets Python dans Rust et d'effectuer des appels de bibliothèque. Un exemple dans la documentation montre comment initialiser le runtime Python, importer des modules, créer des objets Python et exécuter des appels de méthode.

La cpythoncaisse comprend également quelques macros utiles . La py_fn!macro, par exemple, encapsule une fonction Rust afin qu'elle soit appelable depuis Python. La py_class!macro vous permet de générer des classes Rust en tant qu'objets de classe Python.

Si vous êtes plus familier avec Rust qu'avec Python, c'est une bonne idée d'avoir au moins une connaissance passagère de l' API Python C et des différents types d'objets Python avant de plonger.

Conseil sur les performances

Une mise en garde importante avec les deux cpythonet PyO3 est de toujours minimiser le nombre de fois que les données sont transmises entre les deux langues. Chaque appel de Python à Rust ou vice versa entraîne des frais généraux. Si les frais généraux l'emportent sur le travail que vous effectuez dans Rust, vous ne constaterez aucune amélioration significative des performances.

Par exemple, si vous bouclez sur une collection d'objets, envoyez l'objet à Rust et effectuez la boucle là-bas. C'est plus efficace que de boucler du côté Python et d'appeler le code Rust à chaque itération de la boucle.

Cette directive s'applique également généralement aux intégrations entre Python et d'autres codes qui utilisent l'ABI Python C, tels que les modules Cython.

Lien : https://www.infoworld.com/article/3664124/how-to-use-rust-with-python-and-python-with-rust.html

#python #rust

Comment Utiliser Rust Avec Python Facilement Et inversement
Nellie  Kemmer

Nellie Kemmer

1660811580

Auth: Effortless Authentication for Your Web Application on React

Set up the Authentication server

In order to quickly get everything up and running locally, we'll use docker compose[^1].

create a docker-compose.yml file in your project directory

Copy and paste the configuration below. Our compose file contains three services:

  • Postgres[^2] - Our main data store.
  • MailHog[^3] - Used for local development, mailhog.
  • Vulpo Auth - The authentication server.
version: '2'
services:
  postgres:
    image: postgres
    container_name: vulpo_pg
    restart: always
    environment:
      POSTGRES_PASSWORD: postgres
      POSTGRES_USER: postgres
    ports:
      - 5432:5432
    volumes:
      - postgres-data:/var/lib/postgres

  mailhog:
    image: mailhog/mailhog
    container_name: vulpo_mailhog
    restart: always
    ports:
      - 1025:1025
      - 8025:8025
    volumes:
      - mailhog-data:/var/lib/mailhog
  vulpo:
    image: riezler/vulpo_auth
    container_name: vulpo_auth_server
    restart: always
    environment:
      - VULPO_SECRETS_PASSPHRASE=password
      - VULPO_DB_PORT=5432
      - VULPO_DB_USERNAME=postgres
      - VULPO_DB_PASSWORD=postgres
      - VULPO_DB_LOG_LEVEL=Off
      - VULPO_DB_HOST=vulpo_pg
      - VULPO_DB_DATABASE_NAME=auth
      
      
      # this should only be used for local development
      # in production you should run migrations separatly
      # before you run your container
      - VULPO_RUN_MIGRATIONS=true
      
      # this will use an insecure smtp connection and should
      # only be used for local development
      - VULPO_MAIL_LOCALHOST=vulpo_mailhog
    
    ports:
      - 8000:8000
    depends_on:
      - postgres
      - mailhog
volumes:
  postgres-data:
  mailhog-data:
  1. Go to localhost:8000 and finish the set up process

Client Set-up

Enable Email and Password Sign In/Up

  • Go to the admin dashboard
  • Got to your project → Sign In Methods
  • Select Sign In, Sign Up and Email and Password

Create a new React[^4] project: Create React App

npx create-react-app my-app
cd my-app
npm start
  1. Install the vulpo auth packages
npm install @vulpo-dev/auth-ui react-router-dom
  1. Setup the Auth Client:
import React from 'react';
import { createRoot } from 'react-dom/client';
import './index.css';
import App from './App';
import reportWebVitals from './reportWebVitals';
import { BrowserRouter } from 'react-router-dom'

// The Vulpo Auth packages
import { Auth as AuthCtx } from '@vulpo-dev/auth-react'
import { Auth } from '@vulpo-dev/auth-sdk'
import '@vulpo-dev/auth-ui/styles.css' // Default styles

let AuthClient = Auth.create({
  // Got to localhost:8000 -> Your Project -> Settings
  project: '<project-id>',
  baseURL: 'http://localhost:8000'
})

let container = document.getElementById('root')
let root = createRoot(container) // createRoot(container!) if you use TypeScript

root.render(
  <React.StrictMode>
    <BrowserRouter>
      {/* Wrap your application inside the Auth Context */}
      <AuthCtx.Provider value={AuthClient}>
        <App />
      </AuthCtx.Provider>
    </BrowserRouter>
  </React.StrictMode>
);
// If you want to start measuring performance in your app, pass a function
// to log results (for example: reportWebVitals(console.log))
// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
reportWebVitals();
  1. Update your App.js component to make use of the AuthShell
import React from 'react'
import { Route, Link } from 'react-router-dom'
import {
	AuthShell,
	useUser,
	PrivateRoute,
	PublicRoute
} from '@vulpo-dev/auth-ui'

let App = () => {
    return (
        <AuthShell>
           {/* Routes are by default private */}
           <Route path='private' element={<WithUser />} />

           {/* You can also be more explicit */}
           <PrivateRoute path='user' element={<WithUser />} />

           {/* A PublicRoute will be accessible by everyone */}
           <PublicRoute path='/' element={
             <div>
               <h1>Public Page</h1>
               <Link to="private">Private Route: Route</Link>
               <Link to="user">Private Route: PrivateRoute</Link>
             </div>
            }/>
        </AuthShell>
    )
}
export default App

let WithUser = () => {
    let user = useUser()
    return (
        <div>
  
          <h1>With User </h1>
            <Link to="page">Page</Link>
            <pre>{JSON.stringify(user, null, 2)}</pre>
        </div>
    )
}
  1. Congrats, you have completed the set up!

Making API Calls

The web SDK provides a withToken method that manages your token life cycle. Given the WithUser component we have set up in the previous step, import the withAuth hook to get access to the web SDK.

import { useUser, useAuth } from '@vulpo-dev/auth-react'

let WithUser = () => {
   let user = useUser()
   let auth = useAuth()
   
   async function callApi() {
    try {
      let res = await auth.withToken((token) => {
        return fetch('your.api-server.com', {
          headers: {
            'Authorization': `Bearer ${token}`,
          }
        })
      })

      console.log(await res.text())
    } catch(err) {
      console.log({ err })
    }
  }
   
   return (
        <div>
            <h1>With User </h1>
            <Link to="page">Page</Link>
            <button onClick={callApi}>Call API</button>
            <pre>{JSON.stringify(user, null, 2)}</pre>
        </div>
    )
}

All that's left to do is now to verify the JWT on the server. Here is an example of how you would do that using node[^5], express[^6] and passport[^7]. In order to verify the JWT, we need to grab the projects public key, go to: Dashboard -> Your Project -> Settings -> Scroll to the bottom.

let express = require('express')
let cors = require('cors')
let fs = require('fs')
let passport = require('passport')
let JwtStrategy = require('passport-jwt').Strategy
let ExtractJwt = require('passport-jwt').ExtractJwt

// This is the public key that you can find in the admin dashboard
let publicKey = fs.readFileSync('../key.pub', { encoding: 'utf8' })

let opts = {
	jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
	secretOrKey: publicKey,
}

passport.use(new JwtStrategy(opts, function(jwt_payload, done) {
    done(null, jwt_payload)
}))

let app = express()

app.use(cors())

app.get('/',
	passport.authenticate('jwt', { session: false }),
	(req, res) => { res.json(req.user) }
)

app.listen(8001, () => {
	console.log('Node Passport server is running')
})

Footnotes

[^1] https://docs.docker.com/compose/gettingstarted/
[^2] https://www.postgresql.org/
[^3] https://github.com/mailhog/MailHog
[^4] https://reactjs.org
[^5] https://nodejs.org
[^6] https://expressjs.com/
[^7] https://www.passportjs.org/


Author: vulpo-dev
Source code: https://github.com/vulpo-dev/auth
License: MPL-2.0 license
#react #typescript  #rust 

Auth: Effortless Authentication for Your Web Application on React
Thierry  Perret

Thierry Perret

1660811400

Rust 1.63 : Quoi De Neuf ?

Rust a été conçu pour faciliter le développement de logiciels rapides et sûrs au niveau du système. Voici ce qu'il y a de nouveau.

L'approche unique du langage de programmation Rust donne un meilleur code avec moins de compromis que C, C++, Go et les autres langages que vous utilisez probablement. Il est également mis à jour régulièrement, souvent tous les mois.

Où télécharger la dernière version de Rust

Si vous avez déjà une version précédente de Rust installée via rustup, vous pouvez accéder à la dernière version via la commande suivante :

$ rustup update stable

Les nouveautés de Rust 1.63

Publié le 11 août, Rust 1.63 ajoute des threads à portée à la bibliothèque standard. Les threads délimités vous permettent de générer un thread en empruntant au cadre de pile local. L' std::thread::scopeAPI fournit une garantie que tous les threads générés auront quitté avant leur retour, permettant d'emprunter des données en toute sécurité. Rust 1.63 active également les durées de vie non lexicales (NLL) par défaut ; la fonctionnalité est maintenant entièrement stable. NLL est la deuxième itération du vérificateur d'emprunt de Rust.

Également dans Rust 1.63 :

  • Pour la sécurité des E/S, des types de wrapper sont fournis tels que BorrowedFDet OwnedFD, qui sont marqués comme #[repr(transparent)], ce qui signifie que les extern "C"liaisons peuvent prendre ces types pour encoder la sémantique de propriété.
  • Les fonctions Condvar::New, Mutex::Newet RwLock::newsont désormais appelables dans constdes contextes, pour éviter l'utilisation de caisses telles que lazy_static pour créer des statiques globales avec Mutex, RwLockou Condvar. Cela s'appuie sur le travail de Rust 1.62 pour permettre des mutex plus rapides et plus fins.
  • Un certain nombre d'API ont été stabilisées, notamment array::from_fn, Box::into_pinet Path::try_exists.

Les nouveautés de Rust 1.62

Rust 1.62, arrivé le 30 juin, permet aux développeurs d'ajouter des dépendances directement depuis la ligne de commande en utilisant cargo add. Cette commande prend en charge la spécification des versions et des fonctionnalités et peut également modifier les dépendances existantes. Rust 1.62 permet également l'utilisation de #[derive(Default)] sur les énumérations si une variante par défaut est spécifiée.

Autres nouvelles fonctionnalités de Rust 1.62 :

  • La bibliothèque standard de Rust est désormais livrée avec une implémentation brute basée sur futex des verrous sous Linux, qui est légère et ne comporte aucune allocation supplémentaire. Cet ajout fait partie d'un effort visant à améliorer l'efficacité des types de serrures Rust.
  • Il est maintenant plus facile de construire des binaires sans système d'exploitation pour x86_64, par exemple lors de l'écriture d'un noyau. La cible x86_64-unknown-none a été promue au niveau 2 et peut être installée avec rustup.
  • Un certain nombre d'API ont été stabilisées, notamment bool::then_some, f32::total_cmp, f64::total_cmp et Stdin::lines.

Vidéo connexe : Développer des logiciels plus sûrs avec Rust

Familiarisez-vous rapidement avec le nouveau venu Rust, conçu pour créer des logiciels rapides au niveau du système. Cet explicateur animé de deux minutes montre comment Rust contourne les problèmes de programmation vexants de la mémoire et de la gestion.

LOGICIEL

Le langage Rust : développer des logiciels plus sûrs

Les nouveautés de Rust 1.61

Publié le 19 mai, Rust 1.61 met en évidence les codes de sortie personnalisés de main. Les partisans de Rust ont déclaré qu'au début, mainseules les fonctions Rust pouvaient renvoyer le type d'unité ()implicitement ou explicitement, indiquant le succès de l'état de sortie, et si les développeurs voulaient le contraire, ils devaient appeler process::exit. Depuis Rust 1.26, main a été autorisé à renvoyer un Result, où il est Oktraduit en C EXIT_SUCCESSet Erren EXIT_Failure. Ces types de retour alternatifs ont été unifiés par un trait de terminaison instable. Dans cette version, Termination trait est stable, avec un ExitCodetype plus général qui englobe les types de retour spécifiques à la plate-forme. LaTermination trait peut également être implémenté pour les propres types d'un développeur, permettant la personnalisation des rapports avant la conversion en ExitCode.

Également dans la version 1.61 :

  • Plusieurs fonctionnalités incrémentielles ont été stabilisées pour permettre plus de fonctionnalités dans const. Les développeurs peuvent désormais créer, transmettre et convertir des pointeurs de fonction dans un const fn, ce qui peut être utile pour créer des tables de fonctions au moment de la compilation pour un interpréteur. Mais il n'est toujours pas permis d'appeler des fn pointeurs. Les développeurs peuvent également désormais écrire des limites de trait sur des paramètres génériques dans const fn, tels que T: Copy, là où auparavant, seul Sizedétait autorisé. De plus, const fnmaintenant peut traiter des objets de trait, alors que les arguments et les valeurs de retour pour peuvent être des types const fnopaques .impl Trait
  • Les API ont été stabilisées telles que Pin::static_mut, Pin;;static_refet Vec::retain_mut.
  • Auparavant, la création de poignées verrouillées pour stdin/stdlout/stderrempruntait les poignées verrouillées, ce qui empêchait l'écriture let out = std::io::stdout().lock();car outsurvivrait à la valeur de retour de stdout(). Ce code fonctionne maintenant, éliminant un écueil courant affectant de nombreux utilisateurs de Rust.

Les nouvelles fonctionnalités de Rust 1.60.0

Rust 1.60, introduit le 7 avril 2022, stabilise la prise en charge de l'instrumentation de couverture basée sur LLVM dans rustc. Cela fournit une couverture de code basée sur la source. Les développeurs peuvent essayer cela en reconstruisant leur code avec -Cinstrument-coverage. Ensuite, l'exécution du binaire résultant produira un fichier default.profraw dans le répertoire courant.

Le llvm-tools-previewcomposant comprend llvm-profdatale traitement et la fusion de la sortie de profil brute, llvm-profdatale traitement de la sortie de fichier brut et llvm-covla génération de rapports. La fonctionnalité de base est stable et existera dans toutes les futures versions de Rust, mais le format de sortie spécifique et les outils LLVM qui le produisent sont susceptibles de changer. Les développeurs doivent utiliser la même version pour les deux llvm-tools-previewet le rustcbinaire utilisé pour compiler le code.

Rust 1.60 réactive également la compilation incrémentielle. L'équipe Rust continue de travailler sur la correction des bogues de manière incrémentielle, mais aucun problème causant une casse généralisée n'est connu pour le moment.

 Également dans Rust 1.60 :

  • Sur toutes les plates-formes, Instantessaiera d'utiliser une API de système d'exploitation qui garantit un comportement monotone si disponible. En pratique, ces garanties sont, dans de rares circonstances, brisées par des bogues matériels, de virtualisation ou de système d'exploitation. Pour contourner ces bogues et travailler avec des plates-formes dépourvues d'horloges monotones, Instant::duration_since, Instant::elapsedet Instant::subsaturent désormais à zéro. Dans les anciennes versions de Rust, cela provoquait plutôt une panique.
  • Cargo a mis en place un support pour la collecte d'informations sur la construction avec le --timingsdrapeau.
     
  • Des dépendances à espace de noms et des fonctionnalités de dépendance faible ont été introduites pour améliorer la prise en charge des fonctionnalités Cargo et leur interaction avec les dépendances facultatives. Les fonctionnalités Cargo fournissent un mécanisme pour exprimer la compilation conditionnelle et les dépendances facultatives.
  • Un certain nombre d'API ont été stabilisées telles que Arc::new_cyclic, Rc::new_cyclicet slice::EscapAscii.

Les nouvelles fonctionnalités de Rust 1.59.0

Rust 1.59.0 a été annoncé le 24 février. Une fonctionnalité clé est la prise en charge de l'assemblage en ligne, permettant à de nombreuses applications nécessitant un contrôle de très bas niveau sur l'exécution ou l'accès à des instructions machine spécialisées. Le langage d'assemblage et les instructions disponibles avec l'assemblage en ligne varient selon l'architecture. La fonctionnalité est actuellement prise en charge sur des architectures telles que x86 et x64, ARM, Risc-V et AArch64. 

Autres nouvelles fonctionnalités et améliorations de Rust 1.59.0 :

  • Les développeurs peuvent désormais utiliser des modèles de tranche, de tuple et de structure comme côté gauche d'une affectation, ce qui rend l'affectation plus cohérente avec les letliaisons, qui prennent déjà en charge ces modèles.
  • Les types génériques peuvent désormais spécifier des valeurs par défaut pour les constgénériques.
  • Le gestionnaire de packages Cargo affiche désormais des avertissements lorsqu'une dépendance sera rejetée par une future version de Rust.
  • Pour la création de binaires dépouillés, cargo et rustc prennent désormais en charge la suppression lorsque le binaire est lié. Les développeurs de Rust ont déclaré qu'il est souvent utile de supprimer les informations inutiles telles que les informations sur les bogues des fichiers binaires distribués, ce qui les rend plus petits.
  • La compilation incrémentielle est désactivée par défaut. Cela atténue l'effet d'un bogue connu qui provoque des erreurs de désérialisation. Un correctif pour ce bogue sera disponible dans la version bêta de Rust 1.60 prévue dans six semaines.
  • Un certain nombre d' API ont été stabilisées .

Les nouvelles fonctionnalités de Rust 1.58.1

Cette version ponctuelle arrivant le 20 janvier 2022, quelques jours seulement après Rust 1.58, corrige une condition de concurrence dans la std::fs::remove_dir_allfonction de bibliothèque standard. Cette vulnérabilité est suivie à CVE-2022-21658 et un avis a été publié . Un attaquant pourrait utiliser ce problème de sécurité pour inciter un programme privilégié à supprimer des fichiers et des répertoires auxquels l'attaquant ne pourrait autrement pas accéder ou supprimer. Les versions Rust 1.0 à 1.58 sont affectées par cette vulnérabilité. Les utilisateurs sont invités à mettre à jour leurs chaînes d'outils et à créer des programmes avec le compilateur mis à jour.

Rust 1.58.1 corrige également plusieurs régressions dans les diagnostics et les outils introduits dans Rust 1.58 :

  • La non_send_fields_in_send_typeluche Clippy s'est avérée avoir trop de faux positifs et a été déplacée vers le groupe expérimental de peluches appelé "pépinière".
  • La useless_formatpeluche Clippy a été mise à jour pour gérer les identifiants capturés dans les chaînes de format, introduites dans Rust 1.58.
  • Une régression Rustfmtempêchant le formatage des fichiers générés lorsqu'ils sont passés par l'entrée standard a été corrigée.
  • Un message d'erreur incorrect affiché par rustcdans certains cas a été corrigé.

Les nouveautés de Rust 1.58

Rust 1.58, annoncé le 13 janvier, propose des identifiants capturés dans des chaînes de format. Grâce à cette fonctionnalité, les chaînes de format peuvent désormais capturer des arguments en écrivant {ident}dans la chaîne. Les formats acceptent depuis longtemps les arguments de position et les arguments nommés, tels que :

println!("Hello, {}!", get_person());     // implicit position
println!("Hello, {0}!", get_person());     // explicit index
println!("Hello, {person}!", person = get_person());     // named

Désormais, les arguments nommés peuvent également être capturés à partir de la portée environnante.

Autre nouveauté de Rust 1.58 : sur les cibles Windows, std::process::Commandne recherchera plus le répertoire actuel pour les exécutables, ce qui était un effet du comportement historique de l' CreateProcessAPI win32. Cela corrige une situation dans laquelle les recherches pouvaient entraîner un comportement surprenant ou des résultats malveillants lors de la gestion de répertoires non approuvés. 

Rust 1.58 introduit également plus #[must_use]dans la bibliothèque standard. L' #[must use]attribut peut être appliqué à des types ou à des fonctions lorsqu'ils ne les considèrent pas explicitement ou que leur sortie est presque certainement un bogue. Rust 1.58 a également des API stabilisées telles que Metadata::is_symlinkcodeet Path::is_symlink.

Les nouveautés de Rust 1.57

Rust 1.57, dévoilé le 2 décembre, apporte panic!(pour terminer un programme dans un état irrécupérable) des constcontextes. Auparavant, la panic!macro n'était pas utilisable dans const fnet d'autres contextes de compilation. Celle-ci est maintenant stabilisée. Parallèlement à la stabilisation de panic!, plusieurs autres bibliothèques standard sont désormais utilisables dans const, telles que assert!. Mais cette stabilisation n'inclut pas encore toute l'infrastructure de formatage. La panic!macro doit être appelée avec une chaîne statique ou une seule valeur interpolée à utiliser avec {}. Ce soutien devrait s'étendre à l'avenir.

Autres nouvelles fonctionnalités et améliorations de Rust 1.57 :

  • Cargo ajoute la prise en charge des profils nommés arbitrairement.
  • try_reservea été stabilisé pour Vec, String, HashMap, HashSet, et VecDeque. Cette API permet aux appelants d'allouer de manière faillible un stockage de sauvegarde pour ces types.
  • Plusieurs autres API ont été stabilisées, notamment [T; N]::as_mut_sliceet [T; N]::as_slice.
  • Les attributs de macro peuvent maintenant suivre #deriveet verront l'entrée d'origine.

Les nouveautés de Rust 1.56

Annoncée le 21 octobre, Rust 1.56 est la première version du langage qui prend en charge l' édition Rust 2021 . L'édition Rust 2021 permet aux auteurs de caisses Rust d'opter pour des changements de langage qui rendent Rust plus facile à utiliser et plus cohérent. Les caisses peuvent s'inscrire à tout moment et rester interopérables avec les caisses des anciennes éditions. Le compilateur Rust prend en charge les trois éditions du langage : 2015, 2018 et 2021.

Les autres nouvelles fonctionnalités de Rust 1.56 incluent :

  • Capture disjointe dans les fermetures , pour simplifier l'écriture des fermetures.
  • Cargo.toml prend désormais en charge un [package] [rust-version]champ pour spécifier la version minimale de Rust prise en charge pour une caisse, et Cargo se terminera avec une erreur précoce si cela n'est pas satisfait. Bien que cela n'influence pas actuellement le résolveur de dépendances, l'intention est de détecter les problèmes de compatibilité avant qu'ils ne se transforment en erreurs de compilateur cryptiques.
  • Les nouvelles liaisons dans binding@pattern sont prises en charge. La correspondance de modèle de rouille peut être écrite avec un seul identifiant qui lie la valeur entière, suivi d' @un modèle structurel plus raffiné, mais n'a pas autorisé de liaisons supplémentaires dans ce modèle jusqu'à présent. Cette fonctionnalité était autorisée avant Rust 1.0, mais a été supprimée en raison d'un problème. L'équipe du compilateur a maintenant déterminé que ce modèle est sûr et autorisé dans Rust stable.
  • Les macros de panique attendent désormais toujours des chaînes de format, tout comme printlin!().
  • Un certain nombre d'API ont été stabilisées, notamment std::os::unix::fs::chrootet UnsafeCell::raw_get.

Les nouveautés de Rust 1.55

Annoncé le 9 septembre 2021, Rust 1.55 offre une analyse flottante plus rapide et plus correcte. L'implémentation de la bibliothèque standard de l'analyse flottante a été mise à jour pour utiliser l'algorithme d'Eisel-Lemire, qui apporte des améliorations en termes de vitesse et d'exactitude. Auparavant, certains cas extrêmes n'étaient pas analysés, mais ceux-ci ont maintenant été corrigés.

Également dans Rust 1.55 :

  • L'utilisation de plages ouvertes dans les modèles a été stabilisée.
  • Un certain nombre de méthodes et d'implémentations de traits ont été stabilisées, notamment Bound::clonedet Drain::as_str.
  • Cargo déduplique désormais les erreurs du compilateur et imprime un rapport à la fin de la compilation. Auparavant, lors de l'exécution de commandes cargo test, cargo check ---all targetsou similaires qui construisaient le même crate Rust dans plusieurs configurations, les erreurs et les avertissements pouvaient apparaître en double car les exécutions de rustc étaient exécutées en parallèle et affichaient le même avertissement.

Lien : https://www.infoworld.com/article/3267624/whats-new-in-the-rust-language.html

#rust

Rust 1.63 : Quoi De Neuf ?
加藤  七夏

加藤 七夏

1660811061

如何在 Python 中輕鬆逆向地使用 Rust

Python 和 Rust 似乎佔據了語言頻譜的兩端。在運行時解釋的Python為開發人員提供了一個靈活舒適的編程環境,但代價是原始速度。Rust提供速度和內存安全保證,但要求您學習處理內存操作的新範式。

理論上,這些語言不應該競爭。他們應該合作。在實踐中,他們可以。Rust 可以受益於 Python 的易用性,而 Python 可以受益於 Rust 的速度和安全性。

如果您想將 Rust 與 Python 或 Python 與 Rust 一起使用,您至少需要熟悉這兩種語言才能獲得最佳結果。您還需要確定這兩種語言中的哪一種是您的主要語言,因為每種方法的選項都大不相同。

使用 PyO3 從 Python 調用 Rust

如果 Python 是您的主要語言,那麼與 Rust 集成在概念上與將 Python 與 C 集成的方式相同。用 C 編寫的 Python 的默認實現使用用 C 編寫或使用與 C 兼容的 ABI 的擴展。用 Rust 編寫的使用相同 ABI 的擴展也可以工作,儘管這不是自動的——你必須使用專門為 Rust 函數與 Python C API 提供綁定的 crates。

在 Python 中創建 Rust 綁定

在 Python 中創建 Rust 綁定的最廣泛認可的項目是PyO3。它可用於在 Rust 中編寫 Python 模塊,或將 Python 運行時嵌入到 Rust 二進製文件中。

PyO3 利用了另一個項目Maturin,這是一個使用 Python 打包和綁定來創作 Rust crates 的工具。當安裝在 Python 虛擬環境中時,可以從命令行使用 Maturin 來初始化啟用 Python 綁定的新 Rust 項目。開發人員在 Rust 代碼中使用指令來指示要向 Python 公開哪些 Rust 函數,以及如何將整個 Rust 項目作為可導入模塊公開給 Python。

映射 Rust 和 Python 類型

PyO3 的有用方面之一是它在 Rust 和 Python 類型之間的映射。用 Rust 編寫的函數可以接受原生 Python 類型或從 Python 類型轉換的 Rust 類型。例如,Python 中的 a bytearrayorbytes對象可以優雅地映射到Vec<u8>Rust 中的 a,而strPython 中的 a 可以呈現為 Rust String

[立即註冊 CIO 100:研討會和頒獎大會,8 月 15 日至 17 日]

從 Python 轉換為 Rust 會產生每次調用的成本,但它使您不必在 Rust 代碼中完全使用 Python 類型。在 Cython 世界中,這類似於轉換為 C 類型:每次轉換都有成本,但如果您的目標是完全在 C 中進行數值處理,它們會帶來重大的加速。

使用 cpython crate 從 Rust 調用 Python

如果您主要是 Rust 開發人員,但想在 Rust 應用程序中使用 Python,cpython crate是一種直接的方法。crate 為 CPython 解釋器提供 Rust 綁定, cpython 這是最常見的 Python 運行時(之所以如此命名是因為它是用 C 編寫的)。

Rust 程序可以調用 CPython 解釋器並使用它,允許您在 Rust 中創建和操作 Python 對象並進行庫調用。文檔中的一個示例展示瞭如何初始化 Python 運行時、導入模塊、創建 Python 對象和執行方法調用。

cpythoncrate 還包括一些有用的。例如,py_fn!宏包裝了一個 Rust 函數,以便可以從 Python 調用它。該py_class!宏允許您將 Rust 類生成為 Python 類對象。

如果您對 Rust 比 Python 更熟悉,那麼在深入研究之前至少熟悉Python C API和各種 Python 對像類型是個好主意。

性能提示

兩者cpython和 PyO3 的一個重要警告是始終盡量減少數據在兩種語言之間來回傳遞的次數。從 Python 到 Rust 的每次調用(反之亦然)都會產生一些開銷。如果開銷超過了您在 Rust 中所做的工作,您將不會看到任何顯著的性能改進。

例如,如果您正在循環對象集合,請將對象發送到 Rust 並在那裡執行循環。這比在 Python 端循環並在循環的每次迭代中調用 Rust 代碼更有效。

該指南通常也適用於 Python 與使用 Python C ABI 的其他代碼(例如 Cython 模塊)之間的集成。

鏈接:https ://www.infoworld.com/article/3664124/how-to-use-rust-with-python-and-python-with-rust.html

#python #rust

如何在 Python 中輕鬆逆向地使用 Rust

Rust 1.63: что нового?

Rust был разработан, чтобы упростить разработку быстрого и безопасного программного обеспечения системного уровня. Вот что нового.

Уникальный подход языка программирования Rust приводит к лучшему коду с меньшим количеством компромиссов, чем C, C++, Go и другие языки, которые вы, вероятно, используете. Он также регулярно обновляется, часто каждый месяц.

Где скачать последнюю версию Rust

Если у вас уже установлена ​​предыдущая версия Rust через rustup, вы можете получить доступ к последней версии с помощью следующей команды:

$ rustup update stable

Новые возможности в Rust 1.63

В Rust 1.63, опубликованном 11 августа, в стандартную библиотеку добавлены потоки с ограниченной областью действия. Потоки с заданной областью действия позволяют создавать потоки, заимствуя их из локального фрейма стека. API std::thread::scopeгарантирует, что все порожденные потоки будут завершены до их возвращения, что позволяет безопасно заимствовать данные. Rust 1.63 также включает нелексическое время жизни (NLL) по умолчанию; функция теперь полностью стабильна. NLL — это вторая версия средства проверки заимствования в Rust.

Также в Rust 1.63:

  • Для безопасности ввода-вывода предоставляются типы-оболочки, такие как BorrowedFDи OwnedFD, которые помечены как #[repr(transparent)], что означает, что extern "C"привязки могут использовать эти типы для кодирования семантики владения.
  • Функции Condvar::New, Mutex::New, и RwLock::newтеперь можно вызывать в constконтексте, чтобы избежать использования контейнеров, таких как lazy_static, для создания глобальной статики с помощью Mutex, RwLock, или Condvar. Это основано на работе в Rust 1.62, чтобы включить более быстрые и тонкие мьютексы.
  • Был стабилизирован ряд API, включая array::from_fn, Box::into_pinи Path::try_exists.

Новые возможности в Rust 1.62

Rust 1.62, выпущенный 30 июня, позволяет разработчикам добавлять зависимости непосредственно из командной строки с помощью файлов cargo add. Эта команда поддерживает указание версий и функций, а также может изменять существующие зависимости. Rust 1.62 также позволяет использовать #[derive(Default)] для перечислений, если указан вариант по умолчанию.

Другие новые возможности в Rust 1.62:

  • Стандартная библиотека Rust теперь поставляется с необработанной реализацией блокировок на основе фьютексов в Linux, которая является легкой и не требует дополнительного распределения. Это дополнение является частью усилий по повышению эффективности типов блокировки Rust.
  • Теперь проще собирать двоичные файлы без ОС для x86_64, например, при написании ядра. Цель x86_64-unknown-none была повышена до уровня 2 и может быть установлена ​​с помощью rustup.
  • Был стабилизирован ряд API, включая bool::then_some, f32::total_cmp, f64::total_cmp и Stdin::lines.

Видео по теме: Разработка более безопасного программного обеспечения с помощью Rust

Быстро освойте новичок Rust, предназначенный для создания быстрого программного обеспечения системного уровня. Этот двухминутный анимированный объяснитель показывает, как Rust обходит досадные проблемы программирования с памятью и управлением.

ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ

Язык Rust: разработка более безопасного программного обеспечения

Новые возможности в Rust 1.61

Выпущенный 19 мая, Rust 1.61 выделяет пользовательские коды выхода из файлов main. Сторонники Rust говорили, что вначале mainфункции Rust могли возвращать только тип юнита ()либо неявно, либо явно, указывая на успех в статусе выхода, и если разработчики хотели иначе, они должны были вызывать process::exit. Начиная с Rust 1.26, main было разрешено возвращать a Result, где Okон переводится в C EXIT_SUCCESSи Errв EXIT_Failure. Эти альтернативные типы возврата были объединены нестабильным признаком завершения. В этом выпуске Termination типаж является стабильным, наряду с более общим ExitCodeтипом, обертывающим возвращаемые типы для конкретной платформы. Termination Черта также может быть реализована для собственных типов разработчика, что позволяет настраивать отчеты перед преобразованием в ExitCode.

Также в версии 1.61:

  • Несколько добавочных функций были стабилизированы, чтобы обеспечить большую функциональность в const. Теперь разработчики могут создавать, передавать и приводить указатели функций в const fn, что может быть полезно для построения таблиц функций времени компиляции для интерпретатора. Но по-прежнему не разрешено вызывать fn указатели. Разработчики также теперь могут записывать границы трейтов для универсальных параметров в const fn, например T: Copy, где ранее Sizedэто было разрешено. Кроме того, const fnтеперь можно работать с типаж-объектами, тогда как аргументы и возвращаемые значения const fnмогут быть непрозрачными impl Traitтипами.
  • API были стабилизированы, такие как Pin::static_mut, Pin;;static_refи Vec::retain_mut.
  • Ранее при создании заблокированных дескрипторов to stdin/stdlout/stderrзаимствовались заблокированные дескрипторы, что препятствовало записи , let out = std::io::stdout().lock();поскольку outпереживало бы возвращаемое значение stdout(). Этот код теперь работает, устраняя распространенную ловушку, с которой сталкиваются многие пользователи Rust.

Новые возможности в Rust 1.60.0

Rust 1.60, представленный 7 апреля 2022 года, стабилизирует поддержку инструментария покрытия на основе LLVM в rustc. Это обеспечивает покрытие исходного кода. Разработчики могут попробовать это, перестроив свой код с помощью -Cinstrument-coverage. После этого запуск полученного двоичного файла создаст файл default.profraw в текущем каталоге.

Компонент llvm-tools-previewвключает llvm-profdataв себя обработку и объединение необработанных выходных данных профиля, llvm-profdataобработку необработанных выходных файлов и llvm-covсоздание отчетов. Базовая функциональность стабильна и будет существовать во всех будущих выпусках Rust, но конкретный формат вывода и инструменты LLVM, которые его создают, могут быть изменены. Разработчики должны использовать одну и ту же версию для обоих llvm-tools-previewи rustcдвоичный файл, используемый для компиляции кода.

Rust 1.60 также снова включает инкрементную компиляцию. Команда Rust продолжает работать над исправлением ошибок, но в настоящее время не известно о проблемах, вызывающих массовые поломки.

 Также в Rust 1.60:

  • На всех платформах Instantбудет пытаться использовать API операционной системы, который гарантирует монотонное поведение, если он доступен. На практике такие гарантии в редких случаях нарушаются из-за ошибок оборудования, виртуализации или операционной системы. Чтобы обойти эти ошибки и работать с платформами, на которых отсутствуют монотонные часы, Instant::duration_since, Instant::elapsed, а Instant::subтеперь насыщаются до нуля. В старых версиях Rust это приводило к панике.
  • В Cargo налажена поддержка сбора информации о сборке с --timingsфлагом.
     
  • Для улучшения поддержки функций Cargo и того, как они взаимодействуют с необязательными зависимостями, были введены зависимости с пространством имен и функции слабой зависимости. Функции Cargo предоставляют механизм для выражения условной компиляции и необязательных зависимостей.
  • Был стабилизирован ряд API, таких как Arc::new_cyclic, Rc::new_cyclicи slice::EscapAscii.

Новые возможности в Rust 1.59.0

Rust 1.59.0 был анонсирован 24 февраля. Ключевой особенностью является поддержка встроенного ассемблера, что позволяет многим приложениям, которым требуется очень низкоуровневый контроль над выполнением или доступ к специализированным машинным инструкциям. Язык ассемблера и инструкции, доступные для встроенного ассемблера, различаются в зависимости от архитектуры. В настоящее время эта возможность поддерживается на архитектурах, включая x86 и x64, ARM, Risc-V и AArch64. 

Другие новые функции и улучшения в Rust 1.59.0:

  • Теперь разработчики могут использовать шаблоны срезов, кортежей и структур в качестве левой части присваивания, что делает присваивание более совместимым с letпривязками, которые уже поддерживают эти шаблоны.
  • Универсальные типы теперь могут указывать значения по умолчанию для универсальных типов const.
  • Менеджер пакетов Cargo теперь показывает предупреждения, когда зависимость будет отклонена будущей версией Rust.
  • Для создания зачищенных бинарных файлов, cargo и rustc теперь поддерживают зачистку, когда бинарный файл связан. Разработчики Rust говорят, что часто бывает полезно удалить ненужную информацию, например информацию об ошибках, из распространяемых двоичных файлов, уменьшив их размер.
  • Инкрементная компиляция по умолчанию отключена. Это смягчает влияние известной ошибки , вызывающей ошибки десериализации. Исправление этой ошибки будет доступно в бета-версии Rust 1.60 через шесть недель.
  • Ряд API был стабилизирован .

Новые возможности в Rust 1.58.1

Этот точечный релиз, выпущенный 20 января 2022 года, всего через несколько дней после выхода Rust 1.58, исправляет состояние гонки в функции std::fs::remove_dir_allстандартной библиотеки. Эта уязвимость отслеживается по номеру CVE-2022-21658, и для нее был опубликован бюллетень . Злоумышленник может использовать эту проблему безопасности, чтобы обманом заставить привилегированную программу удалить файлы и каталоги, к которым злоумышленник иначе не мог получить доступ или удалить. Этой уязвимости подвержены версии Rust с 1.0 по 1.58. Пользователям рекомендуется обновить свои цепочки инструментов и создавать программы с помощью обновленного компилятора.

Rust 1.58.1 также устраняет несколько регрессий в диагностике и инструментах, появившихся в Rust 1.58:

  • Было non_send_fields_in_send_tyобнаружено, что у Clippy lint слишком много ложных срабатываний, и он был перемещен в экспериментальную группу lint под названием «питомник».
  • Clippy useless_formatlint был обновлен для обработки захваченных идентификаторов в строках формата, представленных в Rust 1.58.
  • Регрессия в Rustfmtпредотвращении форматирования сгенерированных файлов при передаче через стандартный ввод была исправлена.
  • Исправлено некорректное сообщение об ошибке, отображавшееся rustcв некоторых случаях.

Новые возможности в Rust 1.58

Rust 1.58, анонсированный 13 января, содержит захваченные идентификаторы в строках формата. Благодаря этой возможности строки формата теперь могут захватывать аргументы путем записи {ident}в строку. Форматы уже давно принимают позиционные аргументы и именованные аргументы, такие как:

println!("Hello, {}!", get_person());     // implicit position
println!("Hello, {0}!", get_person());     // explicit index
println!("Hello, {person}!", person = get_person());     // named

Теперь именованные аргументы также могут быть захвачены из окружающей области.

Также новое в Rust 1.58: в целях Windows std::process::Commandбольше не будет выполняться поиск исполняемых файлов в текущем каталоге, что было следствием исторического поведения CreateProcessAPI win32. Это исправляет ситуацию, в которой поиск мог привести к неожиданному поведению или вредоносным результатам при работе с ненадежными каталогами. 

Rust 1.58 также вводит больше #[must_use]в стандартную библиотеку. Атрибут #[must use]может быть применен к типам или функциям, когда они явно не учитываются или их вывод почти наверняка является ошибкой. В Rust 1.58 также есть стабилизированные API, такие как Metadata::is_symlinkcodeи Path::is_symlink.

Новые возможности в Rust 1.57

Rust 1.57, представленный 2 декабря, переносит panic!(для завершения программы в невосстановимом состоянии) constконтексты. Ранее panic!макрос нельзя было использовать в const fnдругих контекстах времени компиляции. Сейчас это стабилизировалось. Вместе со стабилизацией panic!теперь можно использовать несколько других стандартных библиотек const, таких как assert!. Но эта стабилизация еще не включает полную инфраструктуру форматирования. Макрос panic!должен вызываться либо со статической строкой, либо с одним интерполированным значением, которое будет использоваться с {}. Ожидается, что эта поддержка будет расширяться в будущем.

Другие новые функции и улучшения в Rust 1.57:

  • В Cargo добавлена ​​поддержка профилей с произвольными именами.
  • try_reserveстабилизировалась для Vec, String, HashMap, HashSetи VecDeque. Этот API позволяет вызывающим объектам ошибочно выделять резервное хранилище для этих типов.
  • Несколько других API были стабилизированы, включая [T; N]::as_mut_sliceи [T; N]::as_slice.
  • Атрибуты макроса теперь могут следовать #deriveи будут видеть исходный ввод.

Новые возможности в Rust 1.56

Анонсированная 21 октября, Rust 1.56 — первая версия языка, поддерживающая редакцию Rust 2021 . Редакция Rust 2021 позволяет авторам ящиков Rust отказаться от критических изменений языка, которые делают Rust более простым в использовании и более согласованным. К ящикам можно подключиться в любое время, и они останутся совместимыми с ящиками из более ранних выпусков. Компилятор Rust поддерживает все три редакции языка: 2015, 2018 и 2021.

Другие новые возможности Rust 1.56 включают в себя:

  • Непересекающийся захват в замыканиях , чтобы упростить написание замыканий.
  • Cargo.toml теперь поддерживает [package] [rust-version]поле для указания минимальной поддерживаемой версии Rust для ящика, и Cargo завершит работу с ранней ошибкой, если она не будет удовлетворена. Хотя в настоящее время это не влияет на распознаватель зависимостей, целью является устранение проблем совместимости до того, как они превратятся в загадочные ошибки компилятора.
  • Поддерживаются новые привязки в binding@pattern. Сопоставление шаблона Rust может быть записано с помощью одного идентификатора, который связывает все значение, за которым @следует более совершенный структурный шаблон, но до сих пор не допускалось дополнительных привязок в этом шаблоне. Эта функциональность была разрешена до Rust 1.0, но была удалена из-за ненадежности. Теперь команда компилятора определила, что этот шаблон безопасен и допустим в стабильной версии Rust.
  • Макросы паники теперь всегда ожидают строки формата, как printlin!().
  • Был стабилизирован ряд API, включая std::os::unix::fs::chrootи UnsafeCell::raw_get.

Новые возможности в Rust 1.55

Объявленный 9 сентября 2021 года, Rust 1.55 предлагает более быстрый и правильный анализ плавающих чисел. Стандартная библиотечная реализация синтаксического анализа с плавающей запятой была обновлена ​​для использования алгоритма Эйзеля-Лемира, который обеспечивает повышение скорости и точности. Раньше некоторые пограничные случаи не анализировались, но теперь они исправлены.

Также в Rust 1.55:

  • Использование открытых диапазонов в паттернах стабилизировалось.
  • Ряд методов и реализаций трейтов были стабилизированы, включая Bound::clonedи Drain::as_str.
  • Cargo теперь дедуплицирует ошибки компилятора и печатает отчет в конце компиляции. Раньше при запуске cargo test, cargo check ---all targetsили подобных команд, которые создавали один и тот же ящик Rust в нескольких конфигурациях, ошибки и предупреждения могли дублироваться, поскольку выполнения rustc выполнялись параллельно и показывали одно и то же предупреждение.

Ссылка: https://www.infoworld.com/article/3267624/whats-new-in-the-rust-language.html

#rust

Rust 1.63: что нового?

Mediocre: Markdown Note Maker (with Git Sync) using Tauri

Mediocre

Markdown note maker (with Git sync) using Tauri.

Screens

"Startup"

"Example note"

"Command UI"

"Settings"

Tech Stack

Frontend

Backend

Note from Author

Hey 👋. Thanks for coming by!

There have been a lot of learnings since I started this project. Therefore I'd like to rebuild on this later down the line.

Please do not take this for any serious use as its unsupported in its current state. Feel free try it out otherwise!

Your feedback would be highly appreciated. Thanks!


Author: nilaysavant
Source code: https://github.com/nilaysavant/mediocre
License:  MIT license
#react #typescript #rust 
 

Mediocre: Markdown Note Maker (with Git Sync) using Tauri

Как использовать Rust с Python и наоборот

Python и Rust занимают, казалось бы, противоположные концы языкового спектра. Python , интерпретируемый во время выполнения, предлагает разработчикам гибкую и удобную среду программирования, но за счет высокой скорости. Rust обеспечивает скорость и гарантирует безопасность памяти, но требует изучения новой парадигмы обработки операций с памятью.

Теоретически эти языки не должны конкурировать; они должны сотрудничать. А на практике могут. Rust может выиграть от простоты использования Python, а Python может выиграть от скорости и безопасности Rust.

Если вы хотите использовать Rust с Python или Python с Rust, вам нужно хотя бы поверхностно познакомиться с обоими языками, чтобы получить наилучшие результаты. Вам также необходимо решить, какой из двух языков является вашим основным, поскольку варианты для каждого подхода значительно различаются.

Вызов Rust из Python с помощью PyO3

Если Python является вашим основным языком, интеграция с Rust концептуально работает так же, как и интеграция Python с C. Реализация Python по умолчанию, написанная на C, использует расширения, либо написанные на C, либо использующие C-совместимый ABI. Расширения, написанные на Rust и использующие тот же ABI, также будут работать, хотя это и не происходит автоматически — вы должны использовать ящики, предназначенные для привязки функций Rust к Python C API.

Создание привязок Rust в Python

Наиболее широко признанным проектом по созданию привязок Rust на Python является PyO3 . Его можно использовать для написания модулей Python на Rust или для встраивания среды выполнения Python в двоичный файл Rust.

PyO3 использует другой проект, Maturin , который представляет собой инструмент для создания крейтов Rust с упаковкой и привязками Python. При установке в виртуальной среде Python Maturin можно использовать из командной строки для инициализации нового проекта Rust с включенными привязками Python. Разработчик использует директивы в коде Rust , чтобы указать, какие функции Rust должны предоставляться Python, и как предоставлять весь проект Rust Python как импортируемый модуль.

Сопоставление типов Rust и Python

Одним из полезных аспектов PyO3 является его сопоставление между типами Rust и Python . Функции, написанные на Rust, могут принимать либо собственные типы Python, либо типы Rust, преобразованные из типов Python. Например, объект bytearrayor bytesв Python может элегантно сопоставляться с a Vec<u8>в Rust, а a strв Python может отображаться как Rust String.

[ ЗАРЕГИСТРИРОВАТЬСЯ на CIO 100: Symposium & Awards Conference, 15–17 августа ]

При переходе с Python на Rust взимается плата за каждый вызов, но это освобождает вас от необходимости полностью использовать типы Python в коде Rust. В мире Cython это сродни преобразованиям в типы C: за каждое преобразование взимается плата, но они обеспечивают значительное ускорение, если вашей целью является числовая обработка полностью на C.

Вызов Python из Rust с помощью ящика cpython

Если вы в первую очередь разработчик Rust, но хотите использовать Python внутри приложения Rust, крейт cpython — это простой способ сделать это. Крейт  cpython предоставляет привязки Rust к интерпретатору CPython, который является наиболее распространенной средой выполнения Python (назван так потому, что написан на C).

Программы на Rust могут вызывать интерпретатор CPython и работать с ним, позволяя вам создавать объекты Python в Rust и управлять ими, а также выполнять вызовы библиотек. Один из примеров в документации показывает, как инициализировать среду выполнения Python, импортировать модули, создавать объекты Python и выполнять вызовы методов.

В cpythonящике также есть несколько полезных макросов . Макрос py_fn!, например, оборачивает функцию Rust, чтобы ее можно было вызывать из Python. Макрос py_class!позволяет создавать классы Rust как объекты классов Python.

Если вы больше знакомы с Rust, чем с Python, рекомендуется хотя бы поверхностно познакомиться с Python C API и различными типами объектов Python, прежде чем погрузиться в изучение.

Совет по производительности

Важное предостережение в отношении обоих cpythonязыков и PyO3 заключается в том, чтобы всегда сводить к минимуму количество раз, когда данные передаются туда и обратно между двумя языками. Каждый вызов из Python в Rust или наоборот влечет за собой некоторые накладные расходы. Если накладные расходы перевешивают работу, которую вы выполняете в Rust, вы не увидите значительного улучшения производительности.

Например, если вы выполняете цикл по коллекции объектов, отправьте объект в Rust и выполните цикл там. Это более эффективно, чем зацикливание на стороне Python и вызов кода Rust при каждой итерации цикла.

Это руководство также в целом применимо к интеграции между Python и другим кодом, использующим Python C ABI, например модулями Cython.

Ссылка: https://www.infoworld.com/article/3664124/how-to-use-rust-with-python-and-python-with-rust.html

#python #rust

Как использовать Rust с Python и наоборот
田辺  亮介

田辺 亮介

1660796844

Rust 1.63:什麼是熱門?

Rust 旨在使開發快速且安全的系統級軟件變得容易。這是新內容。

與 C、C++、Go 和您可能使用的其他語言相比, Rust 編程語言的獨特方法可以生成更好的代碼,並且妥協更少。它還會定期更新,通常是每月更新一次。

在哪裡下載最新的 Rust 版本

如果您已經通過 rustup 安裝了以前版本的 Rust,您可以通過以下命令訪問最新版本:

$ rustup update stable

Rust 1.63 中的新功能

8 月 11 日發布,Rust 1.63 將作用域線程添加到標準庫中。作用域線程允許您通過從本地堆棧幀借用來生成線程。API 提供了一個保證,std::thread::scope即任何產生的線程在返回之前都會退出,從而可以安全地借用數據。Rust 1.63 還默認啟用非詞法生命週期(NLL);該功能現已完全穩定。NLL 是 Rust 借用檢查器的第二次迭代。

同樣在 Rust 1.63 中:

  • 為了 I/O 安全,提供了包裝器類型,例如BorrowedFDOwnedFD,它們被標記為#[repr(transparent)],這意味著extern "C"綁定可以採用這些類型來編碼所有權語義。
  • 、和函數現在可以在上下文中調用Condvar::New,以避免使用諸如lazy_static 之類的板條箱來創建具有 、 或 的全局靜態變量。這建立在 Rust 1.62 中的工作之上,以實現更快、更薄的互斥鎖。Mutex::NewRwLock::newconstMutexRwLockCondvar
  • 穩定了許多 API,包括array::from_fnBox::into_pinPath::try_exists.

Rust 1.62 中的新功能

6 月 30 日發布的 Rust 1.62 允許開發人員直接從命令行使用cargo add. 該命令支持指定版本和功能,也可以修改現有的依賴項。如果指定了默認變體,Rust 1.62 還允許在枚舉上使用 #[derive(Default)]。

Rust 1.62 中的其他新功能:

  • Rust 的標準庫現在在 Linux 上附帶了一個基於 futex 的原始鎖實現,它是輕量級的,不攜帶任何額外的分配。此添加是提高 Rust 鎖類型效率的努力的一部分。
  • 現在更容易為 x86_64 構建無操作系統的二進製文件,例如在編寫內核時。x86_64-unknown-none 目標已提升到第 2 層,可以使用 rustup 進行安裝。
  • 許多 API 已經穩定,包括 bool::then_some、f32::total_cmp、f64::total_cmp 和 Stdin::lines。

相關視頻:使用 Rust 開發更安全的軟件

快速上手 Rust,旨在創建快速的系統級軟件。這個兩分鐘的動畫解釋器展示了 Rust 如何繞過令人煩惱的內存和管理編程問題。

軟件

Rust 語言:開發更安全的軟件

Rust 1.61 中的新功能

5 月 19 日發布,Rust 1.61 突出了來自main. Rust 支持者表示,一開始,Rustmain函數只能()隱式或顯式返回單元類型,表明退出狀態成功,如果開發人員想要其他方式,他們必須調用process::exit. 從 Rust 1.26 開始,main 已允許返回 a ,Result其中Ok翻譯為 CEXIT_SUCCESSErr. EXIT_Failure這些替代返回類型由不穩定的終止特性統一。在這個版本中,Termination trait 是穩定的,還有一個更通用的ExitCode類型,它包含特定於平台的返回類型。這Termination trait 也可以為開發人員自己的類型實現,允許在轉換為ExitCode.

同樣在 1.61 版中:

  • 一些增量功能已經穩定,以在const. 開發人員現在可以在 a 中創建、傳遞和轉換函數指針const fn,這對於為解釋器構建編譯時函數表可能很有用。但是仍然不允許調用fn 指針。開發人員現在還可以將泛型參數的 trait bound 寫入const fn,例如T: Copy,以前只Sized允許。此外,const fnnow 可以處理 trait 對象,而參數和返回值const fn可以是不透明impl Trait類型。
  • API 已經穩定,例如Pin::static_mutPin;;static_refVec::retain_mut.
  • 以前,創建鎖定句柄 tostdin/stdlout/stderr會藉用被鎖定的句柄,這會阻止寫入,let out = std::io::stdout().lock();因為out會超過 的返回值stdout()。這段代碼現在可以工作,消除了影響許多 Rust 用戶的常見缺陷。

Rust 1.60.0 中的新功能

Rust 1.60 於 2022 年 4 月 7 日推出,穩定了對rustc. 這提供了基於源代碼的覆蓋率。開發人員可以通過使用-Cinstrument-coverage. 之後,運行生成的二進製文件將在當前目錄中生成一個 default.profraw 文件。

llvm-tools-preview組件包括llvm-profdata用於處理和合併原始配置文件輸出、llvm-profdata用於處理原始文件輸出以及llvm-cov用於生成報告。基線功能是穩定的,並且將存在於所有未來的 Rust 版本中,但是產生它的特定輸出格式和 LLVM 工具可能會發生變化。開發人員應該對用於編譯代碼llvm-tools-preview的二進製文件和二進製文件使用相同的版本。rustc

Rust 1.60 還重新啟用了增量編譯。Rust 團隊繼續致力於以增量方式修復錯誤,但目前尚未發現導致廣泛破壞的問題。

 同樣在 Rust 1.60 中:

  • 在所有平台上,Instant將嘗試使用保證單調行為(如果可用)的操作系統 API。在實踐中,這種保證在極少數情況下會被硬件、虛擬化或操作系統錯誤所破壞。要解決這些錯誤,並使用缺少單調時鐘的平台,現在Instant::duration_since飽和為零。在舊版本的 Rust 中,這反而導致了恐慌。Instant::elapsedInstant::sub
  • --timingsCargo 已經建立了對使用標誌收集有關構建信息的支持。
     
  • 已引入命名空間依賴項和弱依賴項功能,以改進對 Cargo 功能的支持以及它們如何與可選依賴項交互。Cargo 特性提供了一種機制來表達條件編譯和可選依賴項。
  • 許多 API 已經穩定,例如Arc::new_cyclicRc::new_cyclicslice::EscapAscii.

Rust 1.59.0 中的新功能

Rust 1.59.0 於 2 月 24 日發布。一個關鍵特性是支持內聯彙編,使許多需要非常低級別的執行控製或訪問專用機器指令的應用程序成為可能。內聯彙編可用的彙編語言和指令因體系結構而異。該功能目前在包括 x86 和 x64、ARM、Risc-V 和 AArch64 在內的架構上得到支持。 

Rust 1.59.0 中的其他新功能和改進:

  • 開發人員現在可以使用切片、元組和結構模式作為賦值的左側,使賦值與let已經支持這些模式的綁定更加一致。
  • const泛型類型現在可以為泛型指定默認值。
  • Cargo 包管理器現在會在未來版本的 Rust 拒絕依賴項時顯示警告。
  • 為了創建剝離的二進製文件,cargo 和 rustc 現在支持在鏈接二進製文件時進行剝離。Rust 的開發人員表示,從分發的二進製文件中去除不必要的信息(如 buginfo)通常很有用,從而使它們更小。
  • 增量編譯默認是關閉的。這減輕了導致反序列化錯誤的已知錯誤的影響。Rust 1.60 beta 版將在六週後提供此錯誤的修復。
  • 許多API 已經穩定

Rust 1.58.1 中的新功能

該版本於 2022 年 1 月 20 日發布,就在 Rust 1.58 之後的幾天,修復了std::fs::remove_dir_all標準庫函數中的競爭條件。此漏洞在CVE-2022-21658中被跟踪,並發布了一個公告。攻擊者可以利用此安全問題誘使特權程序刪除攻擊者無法訪問或刪除的文件和目錄。Rust 1.0 到 1.58 版本受此漏洞影響。建議用戶更新他們的工具鏈並使用更新的編譯器構建程序。

Rust 1.58.1 還解決了 Rust 1.58 中引入的診斷和工具中的幾個回歸問題:

  • non_send_fields_in_send_tyClippy lint 被發現有太多誤報,已被轉移到名為“nursery”的實驗 lints 組。
  • useless_formatClippy lint 已更新以處理在 Rust 1.58 中引入的格式字符串中捕獲的標識符。
  • Rustfmt在通過標準輸入時防止生成的文件被格式化的回歸已得到修復。
  • 在某些情況下顯示的不正確錯誤消息rustc已得到修復。

Rust 1.58 中的新功能

1 月 13 日宣布的 Rust 1.58 具有以格式字符串捕獲的標識符。有了這個功能,格式字符串現在可以通過寫入字符串來捕獲參數{ident}。格式早已接受位置參數和命名參數,例如:

println!("Hello, {}!", get_person());     // implicit position
println!("Hello, {0}!", get_person());     // explicit index
println!("Hello, {person}!", person = get_person());     // named

現在,命名參數也可以從周圍的範圍中捕獲。

Rust 1.58 中的另一個新功能:在 Windows 目標上,std::process::Command將不再在當前目錄中搜索可執行文件,這是 win32 CreateProcessAPI 歷史行為的影響。這修復了在處理不受信任的目錄時搜索可能導致意外行為或惡意結果的情況。 

Rust 1.58 還在#[must_use]標準庫中引入了更多內容。當沒有明確考慮它們或它們的輸出幾乎可以肯定是一個錯誤時,該#[must use]屬性可以應用於類型或函數。Rust 1.58 還具有穩定的 API,例如Metadata::is_symlinkcodePath::is_symlink.

Rust 1.57 中的新功能

12 月 2 日發布的 Rust 1.57 將panic!(用於終止處於不可恢復狀態的程序)引入了const上下文。以前,panic!宏在const fn和其他編譯時上下文中不可用。現在這已經穩定下來。隨著 的穩定panic!,現在可以使用其他幾個標準庫,const例如 assert!但這種穩定性還不包括完整的格式化基礎設施。必須使用panic!靜態字符串或單個插值來調用宏,以便與{}. 預計這種支持將在未來擴大。

Rust 1.57 中的其他新功能和改進:

  • Cargo 增加了對任意命名配置文件的支持。
  • try_reserve已穩定Vec, String, HashMap, HashSet, 和VecDeque. 此 API 使調用者能夠錯誤地為這些類型分配後備存儲。
  • 其他多個 API 已經穩定,包括[T; N]::as_mut_slice[T; N]::as_slice.
  • 現在可以跟隨宏屬性#derive並將看到原始輸入。

Rust 1.56 中的新功能

10 月 21 日宣布,Rust 1.56 是支持Rust 2021 版本的語言的第一個版本。Rust 2021 版允許 Rust crate 作者選擇中斷語言更改,使 Rust 更易於使用和更一致。crates 可以隨時選擇加入,並保持與舊版本中的 crates 的互操作性。Rust 編譯器支持該語言的所有三個版本:2015、2018 和 2021。

Rust 1.56 中的其他新功能包括:

  • 閉包中的不相交捕獲,以簡化閉包的編寫。
  • Cargo.toml 現在支持一個[package] [rust-version]字段來指定 crate 支持的最低 Rust 版本,如果不滿足,Cargo 將退出早期錯誤。雖然目前這不會影響依賴解析器,但其目的是在兼容性問題變成隱秘的編譯器錯誤之前捕獲它們。
  • 支持 binding@pattern 中的新綁定。Rust 模式匹配可以用一個綁定整個值的標識符來編寫,然後是@一個更精緻的結構模式,但直到現在才允許在該模式中進行額外的綁定。此功能在 Rust 1.0 之前已被允許,但由於不健全而被刪除。編譯器團隊現在已經確定這種模式在穩定的 Rust 中是安全且允許的。
  • Panic 宏現在總是需要格式字符串,就像printlin!().
  • 許多 API 已經穩定,包括std::os::unix::fs::chrootUnsafeCell::raw_get.

Rust 1.55 中的新功能

2021 年 9 月 9 日宣布,Rust 1.55 提供更快、更正確的浮點解析。浮點解析的標準庫實現已更新為使用 Eisel-Lemire 算法,這帶來了速度和正確性的改進。以前,某些邊緣情況無法解析,但現在已修復。

同樣在 Rust 1.55 中:

  • 模式中開放範圍的使用已經穩定。
  • 許多方法和特徵實現已經穩定,包括Bound::clonedDrain::as_str.
  • Cargo 現在對編譯器錯誤進行重複數據刪除,並在編譯結束時打印報告。以前,當運行cargo testcargo check ---all targets或在多個配置中構建相同的 Rust crate 的類似命令時,錯誤和警告可能會重複顯示,因為 rustc 執行並行運行並顯示相同的警告。

鏈接:https ://www.infoworld.com/article/3267624/whats-new-in-the-rust-language.html

#rust

Rust 1.63:什麼是熱門?
Awesome  Rust

Awesome Rust

1660676160

HomeDisk : Open Source Local Cloud for Your Data Made in Rust

HomeDisk cloud server

👨‍💻 Building

First clone the repository: git clone https://github.com/MedzikUser/HomeDisk.git

Requirements

  • Rust

To build run the command: cargo build --release

The compiled binary can be found in ./target/release/homedisk

Configure

Go to config module

Demo

screenshot-home

screenshot-login

Download details:

Author: MedzikUser
Source code: https://github.com/MedzikUser/HomeDisk
License: GPL-3.0 license

#rust #rustlang

HomeDisk : Open Source Local Cloud for Your Data Made in Rust
Awesome  Rust

Awesome Rust

1660668780

Oxidizer.sh: Extensible Dotfile Management Solution using Rust

Oxidizer.sh

Minimalistic & Extensible Dotfile Management Solution using Rust Toolchains (PRs and Forks are welcome !)

Let's Oxidize Development Environments

1. Get Started

For macOS / Linux

# define path for Oxidizer
export OXIDIZER=$HOME/oxidizer

git clone --depth=1 https://github.com/ivaquero/oxidizer.sh.git $OXIDIZER
bash $OXIDIZER/install.sh

Note that Homebrew is an essential dependency for Oxidizer on macOS / Linux. For China mainland users, you may set BREW_CN variable to install Homebrew through domestic mirror

export BREW_CN=1

For Windows

# define path for Oxidizer
$env:OXIDIZER = "$env:USERPROFILE\oxidizer"

git clone --depth=1 https://github.com/ivaquero/oxidizer.sh.git $env:OXIDIZER
. $env:OXIDIZER\install.ps1

Note that Scoop is an essential dependency for Oxidizer on Windows. For China mainland users, you may set SCOOP_CN variable to install Scoop through domestic mirror

$env:scoop_mirror = 1

After installation, you might personalize your preference in custom.sh (check demo-custom.sh). Open custom.sh by following command

ef ox

To keep up the updates, simply use upox function.

2. Philosophy

Oxidizer is origenally designed for non-administrator users. It quickly sets up a minimal but powerful coding environment, and it aims to provide with following features:

  • Cross-Platform (Mainly Rust Tool chains)
  • Minimal dependencies & Minimal Installation
  • Extensible Architecture
  • Unified Interface & Smooth Usage
  • Super-Fast! (Loading time < 1 s)

3. Oxidization Progress

3.1. Command Line Replacement (Recommand all following)

☑️ means required in the installation.

  •  Use bat instead of cat
  •  Use fd instead of find
  •  Use gitui instead of lazygit
  •  Use lsd instead of ls
  •  Use ls --tree instead of tree
  •  Use ripgrep instead of grep
  •  Use sd instead of sed
  •  Use tealdeer instead of tldr or man
  •  Use zoxide instead of cd or z.lua
  •  Use bottom instead of top or htop
  •  Use dust instead of du
  •  Use tokei instead of cloc

3.2. Software Replacement

  •  Use Wezterm instead of iTerm2 or Windows Terminal (not required, but strongly recommended)
  •  Use Helix instead of NeoVim
  •  Use Nushell instead of Zsh or Powershell

For Nushell: Its nu language is new and will add learning cost. If you'd love to try something new, see oxidizer-next.

3.3. Other Useful Rust Tools

  •  pueue: Command-line task management tool for sequential and parallel execution of long-running tasks.
  •  hyperfine: Command-line benchmarking tool
  •  delta: A syntax-highlighting pager for git, diff, and grep output
  •  mdbook: A utility to create modern online books from Markdown files.

3.4. Summary of Plugins

Oxidizer is designed to be extensible, you can personalize PLUGINS in custom.sh to load the plugins by your need.

Of course, you are allowed to write your own plugins, see 10. Writing A Plugin for details.

indexPluginLinuxmacOSWindowsrequired ?
1Brew
2Scoop
3Utility
4System✅¹
5Pueue
6Git 
7Conan 
8Conda 
9Docker 
10Julia🚧 
11Node 
12Rust 
13TeXLive 
14VS Code 
15Formats🕒🕒🕒 
16Widgets🕒🕒🕒 
17NeoVim    
18Helix    

✅: complete functionality 🚧: partial functionality 🕒: basic functionality, needs more features ❌: not exist

¹: Currently, on Linux only provide with Ubuntu-specific shortcuts.

Oxidizer uses Homebrew or Scoop to manage packages and softwares to bypass the requirement of administrator privilege.

For Linux users, you can try to add Homebrew tap Hombrew-Linux to install GUI Applications.

4. File Management

design

  • ff
    • refresh file by source
  • ef
    • file: edit by $EDITOR (default: VSCode)
  • bf
    • file: browse by bat / cat
    • folder: browse by lsd / ls
  • ipf
    • file: overwrite system configurations by customized (backup) files
  • epf
    • file: export system configurations to back up folder
  • iif
    • file: overwrite system configurations in by Oxidizer defaults.

For example, if you want to edit ~/.zshrc, you can type ef zs.

When you use epf zs, ~/.zshrc will be copied and save in $BACKUP/shell folder, where $BACKUP is the backup path that can be personalized in $OXIDIZER/custom.sh. As mentioned in 1. Get Started, you can open custom.sh simply by ef ox.

The table below shows the informatioin of specific configuration files.

OriginAbbr.Corresponding File
oxidizeroxcustom.sh
zshzs.zshrc
powershellpsProfile.ps1
weztermwzwezterm.lua
aria2araria2.conf
condac.condarc
gitg.gitconfig
conancndefault
conancnrremote.json
helixhxconfig.toml
helixhxllanguages.toml
juliajlsstartup.jl
juliajlpProject.toml
juliajlmManifest.toml
pueuepupueue.yml
pueuepuapueue_aliases.yml
cargocgenv
cargocg_.cargo
neovimnvinit.lua
neovimnvpplugins.lua
neovimnvvinit.vim
vimvi.vimrc
vscodevssettings.json
vscodevskkeybindings.json
vscodevss_snippets
wingetwsettings.json

_ denotes folder

5. Software management

  • back_*
    • file: export package/extension configurations to $BACKUP folder
  • up_*
    • file: update package/extension configurations in $BACKUP folder to system
  • init_*
    • file: install by package/extension configuration files in $Oxygen/install folder

More specifically

  • back_conda: backup Conda package list $BACKUP folder
  • back_node: backup NodeJS package list to $BACKUP folder
  • back_julia: backup Julia package list $BACKUP folder
  • back_texlive: backup TeXLive collection list $BACKUP folder
  • back_vscode: backup VSCode extension list $BACKUP folder

update_* and init_* work similarly.

5.1. NeoVim

For NeoVim, a pure Lua configuration (using init.lua ) is recommended instead of classic Vim configuration (using init.vim ).

However, if you would like to the native vim but haven't configure it, you can try Oxidizer's default configuration by iif vi.

5.2. TeXLive

6. Package Management

Oxidizer aims to provide a unified interface for all package manager-related commands to reduce typing and memory burden of command-line users.

 actionbrew [b]scoop [s]conda [c]npm [n]cargo [cg]rustup [rs]julia [jl]conan [cn]tlmgr [tl]
*hhelp 
*isinstall
*usuninstall
*upupdate
*upsupdate self      
*lslist
*lvleaves   
*scsearch   
*clclean   
*ifinfo   
*ststatus     
*ckcheck   
*pnpin       
*upnunpin       
*dpdepends       
*dptdepend tree       

Particularly, Oxidizer provides with two groups of experimental functions with suffix p for installing and downloading packages in parallel

  • brew: bisp, biscp, bupp, bupap
  • scoop: sisp, supp

For example, when you have more than 1 packages to install, instead of using bis [pkg1] [pkg1], you can use bisp [pkg1] [pkg1] then the packages will be downloaded and installed in parallel.

Similary, biscp, bupp, bupap are the parallel version of bisc, bup, bupa, respectively.

Before using parallel functions, pueue service need to be enabled by

# All OS
pueued -d
# or macOS / Linux
bss pu

Some package managers also have functionality of project management

 actionbrew [b]conda [c]npm [n]cargo [cg]rustup [rs]julia [jl]conan [cn]
*iiinit  
*bbuild    
*rrun  
*eedit     
*tstest  
*pbpublish     

Some of package manager shortcuts are included in corresponding system plugins.

  • zsh-macos [zsm]: auto-loaded, contains mas.
  • zsh-ubuntu [zsub]: contains apt
  • pwsh-windows [pswd]: auto-loaded, contains winget, wsl.
 actionapt [ub]winget [app]wsl [wl]mas [app]
*hhelp 
*isinstall
*usuninstall 
*upupdate 
*upsupdate self   
*lslist 
*lvleaves    
*scsearch  
*clclean   
*ifinfo 
*ststatus   
*ckcheck   
*pnpin    
*upnunpin    
*dpdepends   
*dptdepend tree    

6.1. Homebrew

 Integrated Aria2 to download Homebrew Casks

 Enable Homebrew installation by using pre-download installers

bis: brew install

bris: brew reinstall

suffix c is a flag to specify brew commands only work on casks

  • bisc: brew install --cask
  • brisc: brew reinstall --cask
  • bupc: brew upgrade --cask

suffix a is for all which will force brew to upgrade every cask including ones with auto_update flags

bupa: brew upgrade --greedy

bdl: download brew cask by aria2

brp: replace brew cache file by pre-downloaded file

bmr: using brew mirror

bmrq: reset brew git source to official repositories, q is for quit.

6.2. Conda

Note that the conda plugin is based on mamba (a parallel version of conda) and conda-tree, so you need to install mamba by

conda install -c conda-forge mamba conda-tree

Besides the shortcuts mentioned above in 6. Package Management, the conda plugin also provides with Conda environment management shortcuts which start with ce

  • ceat: activate environment
    • $1 length = 0: activate base env
    • $1 length = 1 or 2: activate predefined env Conda_Env
    • $1 length > 2: activate new env

Conda_Env can be personalize in custom.sh

For example, if you conda environment name is hello, you can set

# macOS / Linux
Conda_Env[h]="hello"
# Windows
$global:Conda_Env.h = "hello"

then, you will be able to manipulate the environment by

# create environment
cecr h
# remove environment
cerm h
# update all packages in the specific environment
cup h
# list all packages in the specific environment
cls h
  • cerat: reactivate environment, works live ceat
  • ceq: quit environment ( q is for kill/quit )
  • cecr: create
  • cerm: remove environment, works live ceat but won't remove base env
  • cels: environment list
  • cesd: change environment's conda-forge subdir
  • ceep: export environment

7. Project & Task Management

Oxidizer's task & system management follows the same phylosopy of package management, i.e. to provide unified interfaces to faciliate workflows.

 actiongit [g]docker 
container [dkc]
docker 
image [dki]
lima [lm]pueue [pu]brew 
services [bs]
*hhelp  
*iiinit     
*dfdiff    
*clclean 
*lslist  
*ststatus    
*sstart  
*rsrestart   
*papause    
*qkill / stop  
*rtreset    
*aadd    
*rmremove  
*eedit    
*plpull    
*pspush    
*ifinfo   

7.1. Git

  •  delete ignored files in .gitignore: gig
  •  find fat blob files: gjk
  •  integration of git filter-repo command
    •  clean files by size bigger than gcl -s
    •  clean files by id gcl -i
    •  clean files by path gcl -p

7.2. Docker

7.3. Pueue

7.4. Homebrew Services

8. Utils Management

8.1. Formats

  •  Convert markdown: mdto
    •  to PDF with Unicode (for CJK)
mdto [filename] [format]

8.2. Widgets

  •  Weather report (using wttr/in)
wtr [location]

9. System Management

9.1. macOS

  • update: update system
  • clean
    • clean: empty trash
    • clean bdl: clean homebrew downloaded files
    • clean cc: clean cache files in $HOME/Library/Caches/
    • clean log: clean logs
  • allow: allow installation of uncertified apps

9.2. Linux

10. Writing A Plugin

A plugin in Oxidizer is refered as Oxygen, a key-value object whose key starts with oxp.

For a Vim plugin on macOS / Linux, you can write

Oxygen[oxpvi]=plugin_path

And add the key of Oxygen into PLUGINS object in custom.sh like

PLUGINS=(oxp1 oxp2 oxpvi)

For Windows users, do these in a similar way

$global:Oxygen.oxpvi = "plugin_path"

And add it into PLUGINS object in custom.ps1

10.1. Config Files

A system / software / tool configuration file in Oxidizer is refered as Element, set it like what you do with Oxygen

# macOS / Linux
Element[vi]=$HOME/.vimrc
# Windows
$global:Element.vi = "$env:USERPROFILE/.vimrc"

If you need to set a folder in Oxygen, plus a _ as the suffix of the key.

# macOS / Linux
Element[vi_]=$HOME/.vim
# Windows
$global:Element.vi_ = "$env:USERPROFILE/vim"

10.2. Backup Files

A backup file in Oxidizer is refered as Oxide whose key starts with bk, set it like

# macOS / Linux
Oxide[bkvi]=$BACKUP/.vimrc
# Windows
$global:Oxide.bkvi = "$env:BACKUP/.vimrc"

Do remember the key in Oxygen, Element, Oxide must be consistent: oxvi, vi, bkvi works, others don't.

11. Credits

Download details:

Author: ivaquero
Source code: https://github.com/ivaquero/oxidizer.sh
License: GPL-3.0 license

#rust #rustlang

Oxidizer.sh: Extensible Dotfile Management Solution using Rust
Awesome  Rust

Awesome Rust

1660668540

The Cobalt AWS wrapper library

This library provides a collection of wrappers around the aws-sdk-rust and lambda_runtime packages.

These wrappers are intended to make it easier to perform common tasks when developing applications which run on AWS infrastructure.

About harrison.ai

This crate is maintained by the Data Engineering team at harrison.ai.

At harrison.ai our mission is to create AI-as-a-medical-device solutions through ventures and ultimately improve the standard of healthcare for 1 million lives every day.

Download details:

Author: harrison-ai
Source code: https://github.com/harrison-ai/cobalt-aws
License: Apache-2.0 license

#rust #rustlang #aws

The Cobalt AWS wrapper library
Awesome  Rust

Awesome Rust

1660661220

How to Display Message on Top using Rust

rust-top_message

Display message on top (all written in Rust)

Dependencies

Install rust-top_message

There are 2 ways to install.

1. Install by cargo

cargo install --git https://github.com/th2ch-g/rust-top_message.git

The executable file is in ~/.cargo/bin/rust-top_message

2. Install from source

git clone https://github.com/th2ch-g/rust-top_message.git && \
cd ./rust-top_message && \
cargo build --release

The executable file is in ./target/release/rust-top_message

Subcommand

USAGE:
    rust-top_message <SUBCOMMAND>

OPTIONS:
    -h, --help       Print help information
    -V, --version    Print version information

SUBCOMMANDS:
    single       one message on one top
    multiple     one message on many top
    multiple2    many message on many top
    long         one long message on many top with newline
    vertical     message on many top vertically
    wave         one message on many top like electric bulletin board
    check        check if top_message can be executed normally
    help         Print this message or the help of the given subcommand(s)

Quick start & Examples

Single mode

$ rust-top_message single -m hello_world -@ 4 -t 20 & top

single_example

Multiple mode

$ rust-top_message multiple -m hello_world -@ 4 -t 20 & top

multiple_example

Multiple2 mode

$ rust-top_message multiple2 -m "hello_world1 hello_world2 hello_world3" -t 20 & top

multiple2_example

Long mode

$ rust-top_message long -m Rust_is_the_greatest_and_best_programming_language_ever -t 20 & top

long_example

Vertical mode

$ rust-top_message vertical -m "ThankYou GoodLuck" -t 20 & top

vertical_example

Wave mode

$ rust-top_message wave -m 123456789 -@ 4 & top

Check by yourself!

Check mode

check if the directories created by rust-top_message remains in current directory

$ rust-top_message check --onlycheck

[CHECK] rustc seems to be installed
[CHECK] .tmp_20220731131724_487375867_68549 is seems to be directory created by rust-top_message
[CHECK] .tmp_20220731131730_903474437_68694 is seems to be directory created by rust-top_message
[CHECK] If you want to delete these directory, please execute --rmcheck option

check the directory created by rust-top_message && remove those directory

$ rust-top_message check --rmcheck

[CHECK] rustc seems to be installed
[CHECK] .tmp_20220731131724_487375867_68549 is seems to be directory created by rust-top_message
[CHECK] .tmp_20220731131730_903474437_68694 is seems to be directory created by rust-top_message
[REMOVED] All directories that rust-top_message may have created were successfully deleted

Subcommand options

Single mode

Option

USAGE:
    rust-top_message single [OPTIONS] --message <STR>

OPTIONS:
    -m, --message <STR>    message that appears on top
    -@, --thread <INT>     thread number [default: 1]
    -t, --time <INT>       display time(s) [default: 10]
        --tmpdir <STR>     tmp directory name [default: ./.tmp_(date_randomnumber_pid)]
    -h, --help             Print help information
    -V, --version          Print version information

Multiple mode

Option

USAGE:
    rust-top_message multiple [OPTIONS] --message <STR>

OPTIONS:
    -m, --message <STR>    message that appears on top
    -@, --thread <INT>     thread number [default: 1]
    -t, --time <INT>       display time(s) [default: 10]
        --tmpdir <STR>     tmp directory name [default: ./.tmp_(date_randomnumber_pid)]
    -h, --help             Print help information
    -V, --version          Print version information

Multiple2 mode

Option

USAGE:
    rust-top_message multiple2 [OPTIONS] --message <"STR STR STR ...">

OPTIONS:
    -m, --message <"STR STR STR ...">
            message that appears on top
            [CAUTION] If more than one messge, "" or '' is necessary
            [CAUTION] number of thread used is automatically determined

    -t, --time <INT>
            display time(s) [default: 10]

        --tmpdir <STR>
            tmp directory name [default: ./.tmp_(date_randomnumber_pid)]

    -h, --help
            Print help information

    -V, --version
            Print version information

Long mode

Option

USAGE:
    rust-top_message long [OPTIONS] --message <STR>

OPTIONS:
    -m, --message <STR>    one long message that appears on top
                           [CAUTION] number of thread used is automatically determined
    -t, --time <INT>       display time(s) [default: 10]
    -l, --length <INT>     characters per top [default: 12]
        --tmpdir <STR>     tmp directory name [default: ./.tmp_(date_randomnumber_pid)]
    -h, --help             Print help information
    -V, --version          Print version information

Vertical mode

Option

USAGE:
    rust-top_message vertical [OPTIONS] --message <"STR STR STR ...">

OPTIONS:
    -m, --message <"STR STR STR ...">
            message that appears on top
            [CAUTION] If more than one messge, "" or '' is necessary
            [CAUTION] number of thread used is automatically determined

    -t, --time <INT>
            display time(s) [default: 10]

        --tmpdir <STR>
            tmp directory name [default: ./.tmp_(date_randomnumber_pid)]

    -h, --help
            Print help information

    -V, --version
            Print version information

Wave mode

Option

USAGE:
    rust-top_message wave [OPTIONS] --message <STR>

OPTIONS:
    -m, --message <STR>    one message on one top like electric bulletin board
                           [CAUTION] number of thread used is automatically determined
    -@, --thread <INT>     thread numer [default: 1]
    -l, --length <INT>     characters per top [default: 12]
        --tmpdir <STR>     tmp directory name [default: ./.tmp_(date_randomnumber_pid)]
    -h, --help             Print help information
    -V, --version          Print version information

Check mode

Option

USAGE:
    rust-top_message check [OPTIONS]

OPTIONS:
        --onlycheck        check that top_message can be executed normally & tmp directory that
                           top_message created
        --onlyrustcheck    check that top_message can be executed normally
        --onlydircheck     check tmp directory that top_message created
        --rmcheck          check that top_message can be executed normally &
                           REMOVE tmp dirctory that top_message created
    -h, --help             Print help information
    -V, --version          Print version information

Recommend alias

Since rust-top_message is a long program name, it is recommended to register alias on your ~/.zshrc and so on.

alias rtm="[Your_rust-top_message_realpath]"

Download details:

Author: th2ch-g
Source code: https://github.com/th2ch-g/rust-top_message
License: MIT license

#rust #rustlang

How to Display Message on Top using Rust
Awesome  Rust

Awesome Rust

1660653720

Databend: A Modern Elasticity and Performance Cloud Data Warehouse

What is Databend?

Databend is an open-source Elastic and Workload-Aware modern cloud data warehouse.

Databend uses the latest techniques in vectorized query processing to allow you to do blazing-fast data analytics on object storage(S3, Azure Blob or MinIO).

Instant Elasticity

Databend completely separates storage from compute, which allows you easily scale up or scale down based on your application's needs.

Blazing Performance

Databend leverages data-level parallelism(Vectorized Query Execution) and instruction-level parallelism(SIMD) technology, offering blazing performance data analytics.

Git-like Storage

Databend stores data with snapshots. It's easy to query, clone, and restore historical data in tables.

Support for Semi-Structured Data

Databend supports ingestion of semi-structured data in various formats like CSV, JSON, and Parquet, which are located in the cloud or your local file system; Databend also supports semi-structured data types: ARRAY, MAP, JSON, which is easy to import and operate on semi-structured.

MySQL/ClickHouse Compatible

Databend is ANSI SQL compliant and MySQL/ClickHouse wire protocol compatible, making it easy to connect with existing tools(MySQL Client, ClickHouse Client, Vector, DBeaver, Jupyter, JDBC, etc.).

Easy to Use

Databend has no indexes to build, no manual tuning required, no manual figuring out partitions or shard data, it’s all done for you as data is loaded into the table.

Architecture

databend-arch

Try Databend

1. Databend Serverless Cloud

The fastest way to try Databend, Databend Cloud

2. Install Databend from Docker

Prepare the image (once) from Docker Hub (this will download about 170 MB data):

docker pull datafuselabs/databend

To run Databend quickly:

docker run --net=host  datafuselabs/databend

Getting Started

Deploying Databend

Connecting to Databend

Loading Data into Databend

Managing Users

Managing Databases

Managing Tables

Managing Views

Managing User-Defined Functions

Backup & Restore

Use Cases

Performance

Contributing

Databend is an open source project, you can help with ideas, code, or documentation, we appreciate any efforts that help us to make the project better! Once the code is merged, your name will be stored in the system.contributors table forever.

To get started with contributing:

Community

For general help in using Databend, please refer to the official documentation. For additional help, you can use one of these channels to ask a question:

  • Slack (For live discussion with the Community)
  • Github (Feature/Bug reports, Contributions)
  • Twitter (Get the news fast)
  • Weekly (A weekly newsletter about Databend)
  • I'm feeling lucky (Pick up a good first issue now!)

Roadmap

Download details:

Author: datafuselabs
Source code: https://github.com/datafuselabs/databend
License: Apache-2.0 license

#rust #rustlang

Databend: A Modern Elasticity and Performance Cloud Data Warehouse
Awesome  Rust

Awesome Rust

1660646220

Sailfish: Simple, Small, and Extremely Fast Template Engine for Rust

sailfish

Simple, small, and extremely fast template engine for Rust

✨ Features

  • Simple and intuitive syntax inspired by EJS
  • Include another template file inside template
  • Built-in filters
  • Minimal dependencies (<15 crates in total)
  • Extremely fast (See benchmarks)
  • Better error message
  • Syntax highlighting support (vscode, vim)
  • Works on Rust 1.42 or later

🐟 Example

Dependencies:

[dependencies]
sailfish = "0.4.0"

Template file (templates/hello.stpl):

<html>
  <body>
    <% for msg in &messages { %>
      <div><%= msg %></div>
    <% } %>
  </body>
</html>

Code:

use sailfish::TemplateOnce;

#[derive(TemplateOnce)]
#[template(path = "hello.stpl")]
struct HelloTemplate {
    messages: Vec<String>
}

fn main() {
    let ctx = HelloTemplate {
        messages: vec![String::from("foo"), String::from("bar")],
    };
    println!("{}", ctx.render_once().unwrap());
}

You can find more examples in examples directory.

🐾 Roadmap

  • Template trait (RFC)
  • Template inheritance (block, partials, etc.)

👤 Author

🇯🇵 Ryohei Machida

🤝 Contributing

Contributions, issues and feature requests are welcome!

Since sailfish is an immature library, there are many planned features that is on a stage of RFC. Please leave a comment if you have an idea about its design!

Also I welcome any pull requests to improve sailfish! Find issues with Status: PR Welcome label, and let's create a new pull request!

Download details:

Author: rust-sailfish
Source code: https://github.com/rust-sailfish/sailfish
License: MIT license

#rust #rustlang

Sailfish: Simple, Small, and Extremely Fast Template Engine for Rust