Reid  Rohan

Reid Rohan

1657795620

Community: Discussion, Support and Common information for Projects

community

Discussion, support and common information for projects in the community.

FAQ

What is Level?

Level is a collection of Node.js modules for creating transparent databases. A solid set of primitives enable powerful databases to be built in userland. They can be embedded or networked, persistent or transient - in short, tailored to your needs.

At the heart of Level are key-value databases that follow the characteristics of LevelDB. They support binary keys and values, batched atomic writes and bi-directional iterators that read from a snapshot in time. Entries are sorted lexicographically by keys which, when combined with ranged iterators, makes for a powerful query mechanism. Level combines idiomatic JavaScript interfaces like async iterators with Node.js interfaces like streams, events and buffers. It offers a rich set of data types through encodings and can split a database into evented sections called sublevels.

The underlying storage can be easily swapped by selecting a different database implementation, all sharing a common API and the same characteristics. Together they target a wide range of runtime environments: Node.js and Electron on Linux, Mac OS, Windows and FreeBSD, including ARM platforms like Raspberry Pi and Android, as well as Chrome, Firefox, Edge, Safari, iOS Safari and Chrome for Android.

Where do I start?

The level module is the recommended way to get started. It offers a persistent database that works in both Node.js and browsers, backed by LevelDB and IndexedDB respectively. Many alternatives are available. For example, memory-level is an in-memory database backed by a red-black tree. Visit Level/awesome to discover more modules.

What is abstract-level?

If you are new to Level, there is a quick answer: abstract-level is the new core of Level on top of which several databases are (or will be) implemented. Read on if you're already familiar with Level modules (before 2022) and have used level, levelup, abstract-leveldown, encoding-down or deferred-leveldown.

Back in 2012, levelup offered a Node.js binding for Google's LevelDB. Authored by Rod Vagg, levelup exposed the features of LevelDB in a Node.js-friendly way. It had streams, binary support, encodings... all the goodies. Later on, the binding was moved to leveldown, so that other stores could be swapped in while retaining the friendly API of levelup.

This is when "up" vs "down" naming was born, where databases followed the formula of "level = levelup + leveldown". For example, level-mem was a convenience package that bundled levelup with memdown. The abstract-leveldown module offered a lower-level abstraction for the "down" part, to encapsulate common logic between "down" stores. Many such stores were written, replacing LevelDB with IndexedDB, RocksDB, in-memory red-black trees, relational databases and more.

Around 2017, further parts were extracted from levelup and moved to single-purpose modules. This effectively introduced the concept of "layers", where an implementation of abstract-leveldown wasn't necessarily a storage for levelup but could also wrap another abstract-leveldown implementation. For example, levelup encoding logic was extracted to encoding-down. This changed the database formula to "level = levelup + encoding-down + leveldown". Or in other words: "levelup + layer + layer".

This highly modular architecture led to clean code, where each module had a single responsibility. By this time, the overall API had settled and matured, some contributors moved on to other exciting things and the primary remaining effort was maintenance. This posed new challenges. We worked on test suites, added automated browser tests, code coverage and database manifests.

Yet, releases too often required canary testing in dependents. It was hard to predict the effect of a change. In addition, documentation became fragmented and some modules actually suffered from the high modularity, having to peel off layers to customize behavior. At the same time, we could see that typical usage of a Level database still involved encodings and the other goodies that the original levelup had.

Enter abstract-level. This module merges levelup, encoding-down and abstract-leveldown into a single codebase. Instead of implementing behaviors "vertically" in layers, it is done per database method. Performance-wise abstract-level is on par with the old modules. GC pressure is lower because methods allocate less callback functions. Custom (userland) database methods also benefit from the new architecture, because they can reuse utility methods included in abstract-level rather than a layer having to detect and wrap custom methods.

Lastly, abstract-level comes with new features, some of which were not possible to implement before. Among them: Uint8Array support, built-in sublevels, atomically committing data to multiple sublevels, and reading multiple or all entries from an iterator in one call.

How do I upgrade to abstract-level?

We've put together several upgrade guides for different modules. For example, if you're currently using level@7 and no other modules (ignoring transitive dependencies) then it will suffice to read the upgrade guide of level@8.

Naming-wise, databases generally use an npm package name in the form of *-level while utilities and plugins are called level-*. This replaces the down versus up naming scheme. Similarly, while it was previously helpful for documentation to distinguish between "database" and its "underlying store", now you will mostly just encounter the term "database".

To upgrade, please consult the following table. If you use a combination of the modules listed here, each must be upgraded to its abstract-level equivalent.

Old moduleNew moduleNamed export 3Upgrade guide
[level][level] <= 7[level][level] >= 8Level[level@8][level@8]
[abstract-leveldown][abstract-leveldown][abstract-level][abstract-level]AbstractLevel[abstract-level@1][abstract-level@1]
[levelup][levelup]n/an/aDepends 2
level or levelup with streams[level-read-stream][l-read-stream]EntryStream[level-read-stream@1][l-read-stream@1]
[leveldown][leveldown][classic-level][classic-level]ClassicLevel[classic-level@1][classic-level@1]
[level-mem][level-mem][memory-level][memory-level]MemoryLevel[memory-level@1][memory-level@1]
[memdown][memdown][memory-level][memory-level]MemoryLevel[memory-level@1][memory-level@1]
[level-js][level-js][browser-level][browser-level]BrowserLevel[browser-level@1][browser-level@1]
[level-rocksdb][level-rocksdb]rocks-levelRocksLevelNot yet available
[rocksdb][rocksdb]rocks-levelRocksLevelNot yet available
[multileveldown][multileveldown][many-level][many-level]ManyLevelGuest[many-level@1][many-level@1]
[level-party][level-party]rave-levelRaveLevelNot yet available
[subleveldown][subleveldown]1n/an/a[abstract-level@1][abstract-level@1]
[deferred-leveldown][def-ld]1n/an/a[abstract-level@1][abstract-level@1]
[encoding-down][encoding-down]1n/an/a[abstract-level@1][abstract-level@1]
[level-errors][level-errors]1n/an/a[abstract-level@1][abstract-level@1]
[level-packager][level-packager]n/an/an/a
[level-supports][supports] <= 2[level-supports][supports] >= 3supportsn/a
[level-codec][level-codec] 4[level-transcoder][transcoder]Transcoder[level-transcoder@1][transcoder@1]
[level-test][level-test]n/an/aNot yet available
  1. Functionality is now included in abstract-level.
  2. If the module that you're wrapping with levelup is listed here then refer to that module's upgrade guide, else see abstract-level@1.
  3. Most new modules use named exports, for example const { ClassicLevel } = require('classic-level') instead of const leveldown = require('leveldown').
  4. Encodings that follow the level-codec interface (without level-codec as a dependency) can still be used.

Where can I get support?

If you need help - technical, philosophical or other - feel free to open an issue in community or a more specific repository. We don't (yet) use GitHub Discussions, at least until discussions get the ability to close them.

You will generally find someone willing to help. Good questions get better and quicker answers. We do not offer paid support. All time is volunteered.

Where can I follow progress?

Most if not all activity happens on GitHub. See our project board to find out what we're working on. Any timelines there are just a rough indication of priority. We cannot guarantee that feature X or Y will actually be released on the given dates.

Subscribe to individual repositories to follow their progress. All releases are accompanied by a changelog and a GitHub Release, which gives you the option to only subscribe to new releases.

People

Collaborators

Collaborator emeriti

Contributors

Is your name missing? Send us a pull request!

API

This repository also used to hold a small amount of metadata on past and present contributors. They can be accessed from code by:

console.log(require('level-community'))

This metadata is no longer maintained and the npm package will be deprecated at some point. Contributors are instead documented in this README under People.

Contributing

Level/community is an OPEN Open Source Project. This means that:

Individuals making significant and valuable contributions are given commit-access to the project to contribute as they see fit. This project is more like an open wiki than a standard guarded open source project.

See the Contribution Guide for more details.

Author: Level
Source Code: https://github.com/Level/community 
License: MIT license

#javascript #node #community #project 

Community: Discussion, Support and Common information for Projects

CoreUI React Is A Free React Admin Template Based on Bootstrap 5

CoreUI Free React Admin Template v3

CoreUI is meant to be the UX game changer. Pure & transparent code is devoid of redundant components, so the app is light enough to offer ultimate user experience. This means mobile devices also, where the navigation is just as easy and intuitive as on a desktop or laptop. The CoreUI Layout API lets you customize your project for almost any device – be it Mobile, Web or WebApp – CoreUI covers them all!

Versions

CoreUI Pro

Only customers with Enterpise Membership Plan have access to private github CoreUI Pro repository.

Installation

Clone repo

# clone the repo
$ git clone https://github.com/coreui/coreui-free-react-admin-template.git my-project

# go into app's directory
$ cd my-project

# checkout stable version
$ git checkout master

# install app's dependencies
$ npm install

Copy and Paste

Copy all your files to your project folder and then,

# go into app's directory
$ cd my-project

# install app's dependencies
$ npm install

Create React App

This project was bootstrapped with Create React App

see also: CRA docs

Basic usage

# dev server with hot reload at http://localhost:3000
$ npm start

Navigate to http://localhost:3000. The app will automatically reload if you change any of the source files.

Build

Run build to build the project. The build artifacts will be stored in the build/ directory.

# build for production with minification
$ npm run build

What's included

Within the download you'll find the following directories and files, logically grouping common assets and providing both compiled and minified variations. You'll see something like this:

CoreUI-React#v3.0.0
├── public/          #static files
│   └── index.html   #html template
│
├── src/             #project root
│   ├── assets/      #assets - js icons object
│   ├── containers/  #container source - template layout
|   │   ├── _nav.js  #sidebar config
|   │   └── ...      
│   ├── scss/        #user scss/css source
│   ├── views/       #views source
│   ├── App.js
│   ├── App.test.js
│   ├── polyfill.js
│   ├── index.js
│   ├── routes.js    #routes config
│   └── store.js     #template state example 
│
└── package.json

Documentation

The documentation for the CoreUI Admin Template is hosted at our website CoreUI for React

:film_strip: How to setup coreui react theme in laravel. Video tutorial available here

Versioning

For transparency into our release cycle and in striving to maintain backward compatibility, CoreUI Free Admin Template is maintained under the Semantic Versioning guidelines.

See the Releases section of our project for changelogs for each release version.

Creators

Łukasz Holeczek

CoreUI team

Community

Get updates on CoreUI's development and chat with the project maintainers and community members.

Copyright and License

copyright 2020 creativeLabs Łukasz Holeczek.

Code released under the MIT license. There is only one limitation you can't can’t re-distribute the CoreUI as stock. You can’t do this if you modify the CoreUI. In past we faced some problems with persons who tried to sell CoreUI based templates.

Support CoreUI Development

CoreUI is an MIT licensed open source project and completely free to use. However, the amount of effort needed to maintain and develop new features for the project is not sustainable without proper financial backing. You can support development by buying CoreUI Pro Version.

We're also open to conversations regarding custom sponsorship / consulting arrangements. Get in touch on Twitter.


Author: coreui
Source code: https://github.com/coreui/coreui-free-react-admin-template
License: MIT license

#Bootstrap #React #javascript 

CoreUI React Is A Free React Admin Template Based on Bootstrap 5
Technewsidea

Technewsidea

1657034111

Python Project - Build Snake Game With Python

Python Project - Build Snake Game With Python.

Python prjects for beginners.

 

#python #numpy #project #programming #game-development #game app development 

Python Project - Build Snake Game With Python
Elian  Harber

Elian Harber

1654597320

Generator-go-project: A Yeoman Generator to Scaffold Golang-project

generator-go-project 

A Yeoman generator to scaffold golang project.

Installation

First, install Yeoman and generator-go-project using npm (we assume you have pre-installed node.js).

npm install -g yo
npm install -g generator-go-project

Then generate your new project:

yo go-project

Getting To Know Yeoman

  • Yeoman has a heart of gold.
  • Yeoman is a person with feelings and opinions, but is very easy to work with.
  • Yeoman can be too opinionated at times but is easily convinced not to be.
  • Feel free to learn more about Yeoman.

Author: Kyoh86
Source Code: https://github.com/kyoh86/generator-go-project 
License: MIT license

#go #golang #project 

Generator-go-project: A Yeoman Generator to Scaffold Golang-project

How to Design a Login and Register Using Tkinter With MySQL Database | Full Python Project

Full Python Project Tutorial Step by Step Using Tkinter With MySQL Database

In this python tutorial we will see how to Design a login and Register form and Connect This Two Forms With MySQL Database.

What We Will Use To Build This Project ? :
- Python Programming Language.
- Visual Studio Code Editor.
- MySQL Database.
- PhpMyAdmin.

What We Will Do In This Project ? :
- design the two forms using frames.
- make your own close button.
- navigate between login frame and signup frame using a label.
- create a connection between python and mysql.
- create a button on each window one to login and the seconde to create a new account.
- create a mysql database to store the users data.
- check if the username or password are empty.
- in the register frame check if the fields are empty
 and if the user renter the correct password .
- create a button to browse image and set the image path in a label and save the image path in the mysql database.
- check If the user enter a username that already exists.

Python Tkinter Widgets We Will Use In This Project:
- Frame.
- Entry (Textfield).
- Button.
- Label.
- RadioButton.


----------------------------------- TABLE OF CONTENT -----------------------------------

▶ 00:00:00 The Final Result Overview
▶ 00:02:45 Create The Project File
▶ 00:04:25 Create and Design The Login Form
▶ 01:18:55 Create a Function to go Show The Login Frame
▶ 01:24:50 Create a Function to go Show The Register Frame
▶ 01:28:00 Create The Browse Image Button
▶ 01:37:22 Create The Database
▶ 01:41:55 Create The Connection With MySQL Database
▶ 01:44:56 Create a Function to Make a New Account
▶ 02:09:30 Create a Function to Allow the User to Login
▶ 02:27:20 Create a Function To Check If The Username Already Exist
▶ 02:39:30 Create The Main Form (Dashboard)

Source Code: https://1bestcsharp.blogspot.com/2022/05/python-login-and-register-form.html 

Subscribe: https://www.youtube.com/c/1BestCsharpblog/featured 

#python  #login  #register  #project  #design  #mysql   #tkinter 

How to Design a Login and Register Using Tkinter With MySQL Database | Full Python Project
高橋  花子

高橋 花子

1653384000

オープンソースプロジェクトを効果的に支援するための5つのボーナスヒント

完璧なスタートアップチームを想像してみてください。小さなグループが互いに効果的にコミュニケーションを取り、物事を成し遂げます。彼らはお互いと彼らの仕事を気にかけ、それは彼らの結果に表れています。

オープンソースプロジェクトはそのようなものでなければなりません。オープンソースプロジェクトで他の人と協力しているときは、同じスタートアップエネルギーを模倣してみてください。

思いやりを持って

オープンソースコミュニティは、プロジェクト、他の人々、そして特に自分自身を気にする人々によって構築されています。

プロジェクトについて

プロジェクトを気にしないのであれば、改善のためにプロジェクトに貢献することのポイントは何ですか?

選択できるプロジェクトは非常に多いので、楽しんでいないプロジェクトに時間を無駄にするのではなく、楽しんでいるプロジェクトに貢献してください。

他の人について

他の画面には常に人がいることを忘れないでください。彼らを敬意を持って扱い、彼らがあなたのために同じことをする可能性が高いことを知ってください。

あなた自身について

とりわけ、あなたは自分自身を気にかけるべきです。自分の時間とメンタルヘルスを尊重してください。

オープンソースプロジェクトに取り組んでいるとき、実際に続行する義務はほとんどありません。それはボランティアの努力であり、それがあなたの精神状態に悪影響を及ぼしている場合は、それをやめてください。あなたはもっと重要です。

明確に通信する

明確なコミュニケーションにより、プロジェクトはスムーズに実行されます。これは、他の人と対話するための最初のステップは、コミュニケーションを公開し続けることであることを意味します。

オープンソースでのコミュニケーションの悪さをよく目にする主な場所は2つあります。

まず第一に、あなたが取り組んでいることを常に他の人に伝えてください。多くの場合、誰かが問題の解決に取り組み始めますが、他の人には言わないでください。すぐに、他の誰かがまったく同じことをし、手遅れになるまで他の誰かが仕事をしていることをどちらも知らず、彼らの両方の努力が無駄になります。

第二に、あなたがするすべてのことで文脈を共有します。バグについて説明するときは、「機能しない」以上のことを言ってください。問題の原因と、それを修正するためにこれまでに何を試みたかを説明してください。ただし、あまり共有しないでください。見つけたタイプミスを修正する前に、誰もあなたのライフストーリーを聞く必要はありません。

フィードバックを活用する

私たちは、他の人からの建設的なフィードバックを一生受け入れるべきだと聞いています。しかし、アドバイスを聞くことと実際にそれを心に留めることには違いがあります。

すべてのオープンソースプロジェクトの大部分はコードレビューです。誰かがいくつかの変更を加えたいときは、最初にそれらを調べる必要があります。お互いに明確にコミュニケーションをとることは、寄稿者と査読者の両方の仕事です。

助けを求める

わからないことや、どうやってやるのかわからないときはどうしますか?あなたは完全に諦めてあなたの努力を放棄しますか、それとも解決策を見つけようとしますか?

あなたが何かで助けを必要とするとき、あなたが見るべき3つの場所があります。まず、自分で問題を解決することから始めます。多くの場合、これは一歩下がって全体像を見るのと同じくらい簡単です。

それでも問題が解決しない場合は、オンラインで検索してみてください。オープンソースで支援するときにあなたが持っているほとんどすべての質問は、おそらく以前に誰かによって尋ねられたので、それをグーグルで検索してください!Stack Overflow、Quora、さらにはRedditなどのサイトで役立つ回答が見つかる可能性があります。

最後に、他のすべてが失敗し、まだ苦労している場合は、作業中のプロジェクトのコミュニティに連絡してください。プルリクエストのコードレビューの最中の場合は、コメントを残して質問してください。

何よりも、質問を避けて際限なく苦労するよりも、どんなに小さな質問でも質問するほうがよいでしょう。

あなたが望む方法で貢献する

オープンソースはコードだけではありません。あなたのスキルセットが何であれ、あなたは間違いなくそれをオープンソースの世界で助けるために使うことができます。

人気のあるGitHubリポジトリを見ると、コードだけではないことがわかります。少なくとも、プロジェクトの詳細が書かれたREADMEファイルがあります。

コードの記述、テスト、レビューの他に、イベントの整理、メディアの設計、プロジェクトについての記述などに取り組むことができます。

オープンソースプロジェクトは成長し変動しているコミュニティ全体であるため、実行できるタスクは無限にあります。

何か新しいことに挑戦します

オープンソースソフトウェアを手伝っているときは、単一​​のコミュニティに限定されないので、少し調べてみてください。

周りを見て、好きなコミュニティを見つけて、すぐに参加してください。アイデアはあるが、そのプロジェクトが存在しない場合は、自分でプロジェクトを開始してください。

新しいオープンソースプロジェクトを開始する方法

どこで支援したいかがわかったら、支援が必要な問題(特に、GitHubで「良い最初の問題」のラベルが付けられた問題)を開いて、それに到達します。

急がないでください

一般的に、オープンソースの作業には実際の期限はありません。オンラインでボランティア活動をしているだけの場合は、他の誰かがあなたが取り組んでいたタスクを引き受けることを除けば、もう少し時間がかかることによる影響はありません。

「後方につまずくためだけに大きな飛躍をするよりも、正しい方向に多くの小さな一歩を踏み出す方が良いです。」(中国のことわざ)

急ぐ必要がないという事実は別として、急いでいる仕事は決してそれほど良くないことも注目に値します。時間をかけて問題を考え、最善の解決策を考えてください。

結論

オープンソースプロジェクトは複雑ですが、複雑である必要はありません。あなたが良いコミュニケーションと社会的スキルを練習し、あなたが助けている理由を知っている限り、あなたは素晴らしいことをするでしょう。

読んでいただきありがとうございます。素敵な一日を!

ソース:https ://betterprogramming.pub/5-bonus-tips-to-help-out-effectively-on-open-source-projects-d5f64e8c04b8

 #opensource #project 

オープンソースプロジェクトを効果的に支援するための5つのボーナスヒント

Consejos Para Ayudar De Manera Efectiva En Proyectos De Código Abierto

Imagine el equipo de inicio perfecto: un pequeño grupo que se comunica de manera efectiva entre sí para hacer las cosas. Se preocupan el uno por el otro y por su trabajo, y eso se nota en los resultados.

Los proyectos de código abierto deberían ser así. Cuando esté trabajando con otros en un proyecto de código abierto, intente imitar esa misma energía de inicio.

Se compasivo

Las comunidades de código abierto están construidas por personas que se preocupan: por el proyecto, por otras personas y especialmente por ellos mismos.

Sobre el proyecto

Si no te importa un proyecto, entonces ¿de qué sirve contribuir a él para lograr una mejora?

Hay tantos proyectos diferentes para elegir, así que contribuya a los que disfruta en lugar de perder el tiempo en los que no.

Acerca de otros

Nunca olvides que siempre hay una persona en la otra pantalla. Trátelos con respeto y sepa que probablemente harán lo mismo por usted.

Acerca de ti mismo

Sobre todo, debes cuidarte a ti mismo. Respeta tu propio tiempo y tu salud mental.

Cuando trabaja en un proyecto de código abierto, casi nunca está obligado a continuar. Es un esfuerzo voluntario, y si tiene un impacto negativo en su estado mental, déjelo. Tú eres más importante.

Comuníquese claramente

Una comunicación clara mantiene los proyectos funcionando sin problemas. Esto significa que el primer paso para interactuar con otros es mantener la comunicación pública.

Hay dos lugares principales donde a menudo veo mala comunicación en código abierto:

En primer lugar, siempre cuéntale a los demás en qué estás trabajando. Con frecuencia, alguien comenzará a trabajar para resolver un problema, pero sin decírselo a nadie más. Pronto, alguien más hace exactamente lo mismo, y ninguno sabe que el otro está haciendo el trabajo hasta que es demasiado tarde, y ambos esfuerzos se desperdician.

En segundo lugar, comparte el contexto en todo lo que haces. Cuando describa un error, diga algo más que "no funciona". Explique qué condujo al problema y qué ha intentado hasta ahora para solucionarlo. Sin embargo, no comparta demasiado. Nadie necesita escuchar la historia de su vida antes de corregir un error tipográfico que encontró.

Utilizar retroalimentación

Hemos escuchado que debemos aceptar comentarios constructivos de los demás durante toda nuestra vida. Sin embargo, hay una diferencia entre escuchar un consejo y realmente tomarlo en serio.

Una gran parte de cada proyecto de código abierto es la revisión del código. Cuando alguien quiere hacer algunos cambios, primero debe revisarlos. Es trabajo tanto del colaborador como del revisor comunicarse claramente entre sí.

Pedir ayuda

Cuando te encuentras con algo que no entiendes o no sabes cómo realizar una tarea, ¿qué haces? ¿Te rindes por completo y abandonas tu arduo trabajo, o tratas de encontrar una solución?

Cuando necesite ayuda con algo, hay tres lugares donde debe buscar. Primero, comience tratando de resolver el problema usted mismo. A menudo, esto es tan simple como dar un paso atrás y mirar el panorama general.

Si eso no funciona, puede intentar buscar en línea. Casi todas las preguntas que tienes cuando ayudas en el código abierto probablemente te las hayan hecho alguien antes, ¡así que solo búscalas en Google! Es probable que encuentre una respuesta útil en sitios como Stack Overflow, Quora o incluso Reddit.

Finalmente, si todo lo demás falla y aún tiene problemas, comuníquese con la comunidad del proyecto en el que está trabajando. Si está en medio de una revisión de código en una solicitud de extracción, simplemente deje un comentario y pregunte.

Sobre todo, es mejor hacer su pregunta, por pequeña que sea, que evitar preguntar y luchar sin cesar.

Contribuye como quieras

El código abierto no se trata solo de código. Cualquiera que sea su conjunto de habilidades, definitivamente puede usarlo para ayudar en el mundo del código abierto.

Si echa un vistazo a cualquier repositorio popular de GitHub, notará que no es solo código. Como mínimo, hay un archivo README escrito con detalles sobre el proyecto.

Además de escribir, probar y revisar el código, puede trabajar en la organización de eventos, el diseño de medios, la redacción de proyectos y más.

Hay un sinfín de tareas que puede realizar porque los proyectos de código abierto son comunidades enteras que crecen y fluctúan.

Intenta algo nuevo

No estás confinado a una sola comunidad cuando ayudas con el software de código abierto, ¡así que explora un poco!

Echa un vistazo, trata de encontrar una comunidad que te guste y lánzate de inmediato. Si tienes una idea, pero no existe un proyecto para ella, ¡comienza uno tú mismo!

Cómo iniciar un nuevo proyecto de código abierto

Una vez que sepa dónde quiere ayudar, abra los problemas que necesitan ayuda (especialmente aquellos etiquetados con una etiqueta de "buen primer problema" en GitHub), ¡y hágalo!

no te apresures

Generalmente, el trabajo de código abierto no tiene una fecha límite real. Si solo está ofreciendo su tiempo como voluntario en línea, no hay consecuencias por tomarse un poco más de tiempo, además de que otra persona asuma la tarea en la que estaba trabajando.

“Es mejor dar muchos pequeños pasos en la dirección correcta que dar un gran salto hacia adelante y tropezar hacia atrás”. (Proverbio chino)

Aparte del hecho de que no necesitas apresurarte, también vale la pena señalar que el trabajo apresurado nunca es tan bueno. Tómese su tiempo, piense en el problema y encuentre la mejor solución.

Conclusión

Los proyectos de código abierto son complejos, pero no tienen por qué ser complicados. Te irá muy bien siempre y cuando practiques una buena comunicación y habilidades sociales y sepas por qué estás ayudando.

Muchas Gracias Por Leer. ¡Ten un día maravilloso!

Fuente: https://betterprogramming.pub/5-bonus-tips-to-help-out-effectly-on-open-source-projects-d5f64e8c04b8

#opensource #project 

Consejos Para Ayudar De Manera Efectiva En Proyectos De Código Abierto

データサイエンスプロジェクト向けの見事なWebアプリを作成する

Web開発は、データサイエンティストのコアコンピテンシーではありません。ほとんどのデータサイエンティストは、それを行うためにさまざまなテクノロジーをわざわざ学ぶ必要はありません。それは彼らのコーヒーではありません。

ただし、ほとんどのデータサイエンスプロジェクトには、ソフトウェア開発コンポーネントもあります。開発者は、問題について異なる理解を持っている場合があり、個別のテクノロジを使用します。それはしばしば問題を引き起こし、両方のチームの貴重な時間を非生産的に浪費します。

また、TableauやPower BIなどの視覚化ツールは、データ探索に重点を置いています。それでも、それは完全なデータサイエンスプロジェクトの一部にすぎません。機械学習モデルを統合する必要がある場合、それらは完璧にはほど遠いです。

Streamlitを使用すると、データサイエンスプロジェクト用のWebアプリを開発できます。このオープンソースライブラリのAPIは完全にPythonです。したがって、それを使用するために他のWebテクノロジーを学ぶ必要はありません。また、習得が簡単で、変更に柔軟に対応できます。

この記事はStr​​eamlitの紹介です。ユーザー入力を受け取り、K-meansアルゴリズムを実行し、結果をWebインターフェイスに即座にプロットするインタラクティブなWebアプリを構築します。

短い記事の終わりまでに、私たちはカバーしたでしょう

  • Streamlitをインストールして水をテストします。
  • インタラクティブなWebアプリの構築。
  • ユーザー入力を使用してK-meansアルゴリズムを実行します。
  • キャッシュを使用してパフォーマンスを向上させる。
  • クラウドにデプロイします。

デプロイされたバージョンへのリンクは次のとおりです。スニークピークが必要な場合は、それをチェックしてください。

 

開発用にStreamlitを設定します。

この並外れたツールのセットアップは非常にシンプルで、ほとんどすべてのPythonユーザーがこのツールに精通しています。PyPIを使用します。

pip install streamlit

condaやその他の一般的なPythonパッケージマネージャーを使用することもできます。

完了したら、インストールに付属しているhelloworldアプリでテストできます。ターミナルウィンドウで以下のコマンドを実行し、開発サーバーを起動します。

streamlit hello

hello worldアプリは、Streamlitで実行できる優れた視覚化のセットです。上記のコマンドは、ローカル開発サーバーを起動し、デフォルトのブラウザでリンクを開きます。同じページでソースコードを見つけることもできます。さらに、このサンプルアプリには、自分自身を教育するための多くの高度なチュートリアルへのリンクもあります。

セットアップが完了したので、機械学習モデルと対話するためのアプリを作成しましょう。

StreamlitWebアプリで機械学習モデルを使用する。

以下のアプリは、Pandas、Scikit-Learn、Matplotlib、Seaborn、およびStreamlitを使用しています。開始する前に、必要なすべてのパッケージがインストールされていることを確認してください。そうでない場合は、以下のコマンドで実行できます。

pip install pandas scikit-learn matplotlib seaborn streamlit

最初のWebアプリを作成する

以下の内容で「quickstart.py」という名前のファイルを作成します。

# Imports
# -----------------------------------------------------------
import streamlit as st
import pandas as pd
# -----------------------------------------------------------

# Helper functions
# -----------------------------------------------------------
# Load data from external source
df = pd.read_csv(
    "https://raw.githubusercontent.com/ThuwarakeshM/PracticalML-KMeans-Election/master/voters_demo_sample.csv"
)
# -----------------------------------------------------------

# Sidebar
# -----------------------------------------------------------

# -----------------------------------------------------------


# Main
# -----------------------------------------------------------
# Create a title for your app
st.title("Interactive K-Means Clustering")

# A description
st.write("Here is the dataset used in this analysis:")

# Display the dataframe
st.write(df)
# -----------------------------------------------------------

著者からのコードスニペット。

上記のファイルは簡単です。説明のために、ファイルにセクションを追加しました。

メインのアプリセクションには、3行あります。ページにタイトルと説明を追加しました。次に、ページにデータフレームを表示します。「st.write」関数はオールインワンソリューションです。この関数にはほとんど何でも渡すことができ、StreamlitはUIに正しいウィジェットを表示するのに十分スマートです。さまざまなStreamlit関数について学ぶために、ここにチートシートがあります。

以下のコマンドで最初のアプリを実行してみましょう。

streamlilt run quickstart.py

helloアプリと同様に、このコマンドは新しい開発サーバーを起動します。ブラウザに以下が表示されます。

著者からのスクリーンショット。

おめでとうございます。最初のWebアプリを作成しました。HTML、CSSがなく、JavaScriptもまったくありません。

しかし、これは初歩的なことです。Webアプリはたくさんのクールなことをすることができます。リアルタイムでユーザーと対話し、コンテンツを更新できます。どうすればそれができるか見てみましょう。

インタラクションの追加

StreamlitWebアプリでインタラクションをもたらすのは簡単です。Streamlit APIには、いくつかのウィジェットが含まれています。それらを使用して、ユーザー入力を取得し、その値を変数に格納できます。残りは他のPythonプログラムと同じです。

データセットの表示を切り替えるチェックボックスを追加しましょう。結局のところ、生データを表示するWebアプリを開発する人は誰もいません。データフレーム表示(30行目)を以下の内容に置き換えてください。

# Display the dataframe
df_display = st.checkbox("Display Raw Data", value=True)

if df_display:
    st.write(df)

著者からのコードスニペット。

ブラウザを更新すると、データフレームの表示を切り替えるためのチェックボックスが表示されます。

著者からのスクリーンショット。

しかし、アプリの中央にあるトグルボタンは快適ではありません。サイドバーに移動しましょう。

アプリにサイドバーを追加する

繰り返しますが、別の楽なアクション。StreamlitAPIにはサイドバープロパティがあります。メインアプリで作成したすべてのウィジェットは、このサイドバープロパティでも利用できます。

'st.sidebar'プロパティを使用してサイドバー変数を作成します。次に、メインアプリセクションで追加したチェックボックスの割り当てをサイドバーセクションに移動します。'st.checkbox'の代わりに'st.sidebar.checkbox'を使用していることに注意してください。

# SIDEBAR
# -----------------------------------------------------------
sidebar = st.sidebar
df_display = sidebar.checkbox("Display Raw Data", value=True)

n_clusters = sidebar.slider(
    "Select Number of Clusters",
    min_value=2,
    max_value=10,
)
# -----------------------------------------------------------

著者からのコードスニペット。

上記のコードでは、サイドバーにスライダーも追加しました。このウィジェットは、ユーザーが選択した数のクラスターをキャプチャします。出力は次のようになります。

著者からのスクリーンショット。

次に、ユーザーが選択した数のクラスターを使用してKmeansアルゴリズムを実行します。

ライブ入力を使用したK-Meansの実行。

以下のコードを使用して、インポート、ヘルパー関数、およびメインアプリセクションを拡張します。

# Imports
# -----------------------------------------------------------
...
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_theme()
# -----------------------------------------------------------

# Helper functions
# -----------------------------------------------------------
...
def run_kmeans(df, n_clusters=2):
    kmeans = KMeans(n_clusters, random_state=0).fit(df[["Age", "Income"]])

    fig, ax = plt.subplots(figsize=(16, 9))

    #Create scatterplot
    ax = sns.scatterplot(
        ax=ax,
        x=df.Age,
        y=df.Income,
        hue=kmeans.labels_,
        palette=sns.color_palette("colorblind", n_colors=n_clusters),
        legend=None,
    )

    return fig
# -----------------------------------------------------------

# MAIN APP
# -----------------------------------------------------------
...
# Show cluster scatter plot
st.write(run_kmeans(df, n_clusters=n_clusters))
# -----------------------------------------------------------

著者からのコードスニペット。

上記のコードでは、K-Meansアルゴリズムを実行する関数を作成しました。データフレームとクラスターの数を引数として取り、Matplotlibの数値を返します。

K-Meansクラスタリングの図は、このプロジェクトの範囲を超えています。これは機械学習アルゴリズムであり、それが私たちの関心事です。しかし、あなたはそれを説明している私の以前の投稿を参照することができます。

run_forecast関数の2番目の引数として、前のセクションのスライダー値をキャプチャするn_clusters変数を使用します。

ページを更新すると、ユーザー入力を受け取り、機械学習アルゴリズムを実行し、UIを即座に更新するダッシュボードが表示されます。

著者からのスクリーンショット。

経験豊富な開発者であっても、このレベルの相互作用とバックエンドMLとの統合は困難な作業です。特に、Webアプリの開発方法を知らないデータサイエンティストの場合は、数週間かかる場合があります。

 

キャッシュによるパフォーマンスの向上。

データサイエンスパイプラインの一部のタスクには時間がかかります。しかし、そのようなタスクが同じ入力に対して異なる結果を生成することはめったにありません。Streamlitの組み込みキャッシュ機能を使用して、将来の使用のためにそれらの値を保存できます。

複雑に聞こえるかもしれませんが、streamlitでそれを行うのは簡単です。時間のかかるタスクは関数である必要があり、@ts.cacheデコレータでラップします。入力パラメーターが同じで、関数の本体が変更されていない限り、Streamlineはそれをキャッシュからフェッチします。

作成したアプリでは、外部URLを呼び出してデータをダウンロードします。ライブAPIの場合は、キャッシュしたくない場合があります。しかし、私たちの場合はそうではありません。したがって、行を次のコードに置き換えてキャッシュしましょう。

# Load data from external source
@st.cache
def load_data():
    df = pd.read_csv(
        "https://raw.githubusercontent.com/ThuwarakeshM/PracticalML-KMeans-Election/master/voters_demo_sample.csv"
    )
    return df

df = load_data()

著者からのコードスニペット。

最初のリロード時に、ブラウザに「Processingload_data」というメッセージが表示される場合があります。しかし、その後のリロードにはそのメモはありません。これは、リクエストが外部URLからダウンロードするのではなく、キャッシュからフェッチされるためです。

 

インターネットでの展開

Streamlitコンソールに気付いた場合は、ネットワークURLも表示されます。つまり、ファイアウォールで許可されている場合は、イントラネットを介してアプリにアクセスできます。

ただし、ネットワークの外部で共有したい場合は、多くのオプションがあります。ドキュメントに記載されているように、StreamlitアプリはPythonアプリが機能する場所ならどこでも機能します。

  1. Streamlitは「Streamlit共有」オプションを推奨します。
    コードをGitHubリポジトリに配置し、アプリを提供するようにStreamlit共有を構成できます。
    Streamlitの共有は無料ですが、現在は招待制です。自分で招待状をリクエストできます。
  2. クラウドプラットフォームにデプロイできます。これは、AWSEC2無料インスタンスでそれを行う方法を示す記事です。
  3. リバースプロキシを設定できます。NginxやApacheなどのプロキシサーバーは、アプリにサービスを提供し、特定のユーザーのアクセスを制限するように構成できます。

展開に関するStreamlitのコミュニティガイドを必ず読んで、利用可能な多数のオプションを調べてください。

このチュートリアルアプリをStreamlitShareにデプロイした方法は次のとおりです。繰り返しになりますが、Streamlitはその便利さで私を驚かせることに失敗しませんでした。

ステップI:コードをGitHubパブリックリポジトリに配置します。このGitHubリポジトリ
にコードを追加しました。すべての依存関係を含むrequirement.txtファイルが含まれていることを確認する必要があります。

ステップII:GitHubアカウントを使用してStreamlitにログインします。

ステップIII:Streamlitコンソールで新しいアプリを作成します。
ドロップダウンまたはURLの過去からgitハブリポジトリを選択します。展開に使用するブランチを選択します。最後に、メインのファイル名を選択して、[デプロイ]をクリックします。

著者によるスクリーンショット。

約1分で、私のアプリはStreamlitShareで公開されます。ただし、展開までの時間は、プロジェクトの要件によって異なる場合があります。

ストリームリット共有は現在、招待のみのものであることに注意してください。しかし、私はそれを手に入れるのにそれほど長く待ちませんでした。Streamlitのデプロイメントドキュメントには、これに関するさらに多くの役立つ情報が含まれています。

 

結論

言うまでもなく、Streamlitはデータサイエンスプロジェクトの重大な問題を解決します。これにより、データサイエンティストは、機械学習モデルと対話するためのWebアプリを構築することができます。

この紹介記事では、K-MeansクラスタリングでStreamlitを使用する方法について説明しました。些細なアプリケーションですが、このテクノロジーのコアコンセプトを示しています。開発に加えて、Streamlitでパフォーマンスのためにキャッシュを管理するのがいかに簡単かを見てきました。最後に、展開オプションについて説明しました。

Streamlitはこれ以上のものです。優れたチュートリアルが満載の公式ドキュメントを確認してください。また、APIチートシートは迅速な開発に役立ちます。

ソース:https ://towardsdatascience.com/how-to-create-stunning-web-apps-for-your-data-science-projects-c7791102134e

#data-science #project 

データサイエンスプロジェクト向けの見事なWebアプリを作成する

Crear Impresionantes Web App Para Sus Proyectos De Ciencia De Datos

El desarrollo web no es la competencia central de un científico de datos. La mayoría de los científicos de datos no se molestan en aprender diferentes tecnologías para hacerlo. Simplemente no es su taza de café.

Sin embargo, la mayoría de los proyectos de ciencia de datos también tienen un componente de desarrollo de software. Los desarrolladores a veces tienen una comprensión diferente del problema y usan tecnologías discretas. A menudo causa problemas y agota el valioso tiempo de ambos equipos de forma improductiva.

Además, las herramientas de visualización como Tableau y Power BI se centran más en la exploración de datos. Sin embargo, es solo una parte de un proyecto completo de ciencia de datos. Si necesita integrar un modelo de aprendizaje automático, están lejos de ser perfectos.

Streamlit le permite desarrollar aplicaciones web para sus proyectos de ciencia de datos. La API de esta biblioteca de código abierto está completamente en python. Por lo tanto, no tiene que aprender ninguna otra tecnología web para usarla. Además, es fácil de aprender y flexible para modificaciones.

Este artículo es una introducción a Streamlit. Construiremos una aplicación web interactiva que toma las entradas del usuario, ejecuta un algoritmo de K-means y traza instantáneamente los resultados en una interfaz web.

Al final del breve artículo, habríamos cubierto

  • instalar Streamlit y probar el agua;
  • Creación de una aplicación web interactiva;
  • ejecutar el algoritmo K-means con entradas de usuario;
  • usar caché para mejorar el rendimiento, y;
  • desplegarlo en la nube;

Aquí está el enlace a la versión implementada. Échale un vistazo si quieres un adelanto.

 

Configuración de Streamlit para el desarrollo.

Esta extraordinaria herramienta tiene una configuración vergonzosamente simple y casi todos los usuarios de Python están familiarizados con ella. Utilice PyPI.

pip install streamlit

También puede usar conda y otros administradores de paquetes populares de python.

Una vez completado, puede probarlo con una aplicación hello world que viene con la instalación. Ejecute el siguiente comando en una ventana de terminal para iniciar el servidor de desarrollo.

streamlit hello

La aplicación hello world es un conjunto de excelentes visualizaciones que puedes hacer con Streamlit. El comando anterior iniciará un servidor de desarrollo local y abrirá el enlace en su navegador predeterminado. También puede encontrar los códigos fuente en la misma página. Además, esta aplicación de muestra también tiene enlaces a muchos tutoriales avanzados para informarse.

Ahora que la configuración está completa, creemos una aplicación para interactuar con nuestro modelo de aprendizaje automático.

Uso de modelos de aprendizaje automático con una aplicación web Streamlit.

La aplicación a continuación usa Pandas, Scikit-Learn, Matplotlib, Seaborn y Streamlit. Antes de comenzar, asegúrese de haber instalado todos los paquetes necesarios. Si no, el siguiente comando lo hará por usted.

pip install pandas scikit-learn matplotlib seaborn streamlit

Creando tu primera aplicación web

Cree un archivo llamado 'quickstart.py' con el siguiente contenido.

# Imports
# -----------------------------------------------------------
import streamlit as st
import pandas as pd
# -----------------------------------------------------------

# Helper functions
# -----------------------------------------------------------
# Load data from external source
df = pd.read_csv(
    "https://raw.githubusercontent.com/ThuwarakeshM/PracticalML-KMeans-Election/master/voters_demo_sample.csv"
)
# -----------------------------------------------------------

# Sidebar
# -----------------------------------------------------------

# -----------------------------------------------------------


# Main
# -----------------------------------------------------------
# Create a title for your app
st.title("Interactive K-Means Clustering")

# A description
st.write("Here is the dataset used in this analysis:")

# Display the dataframe
st.write(df)
# -----------------------------------------------------------

Fragmento de código del autor .

El archivo anterior es sencillo. Con fines ilustrativos, he agregado secciones al archivo.

En la sección principal de la aplicación, tenemos tres líneas. Agregamos un título y una descripción a la página. Luego mostramos el marco de datos en la página. La función "st.write" es una solución todo en uno. Podría pasar casi cualquier cosa a esta función, y Streamlit es lo suficientemente inteligente como para mostrar el widget correcto en la interfaz de usuario. Para obtener información sobre las diferentes funciones de Streamlit, aquí hay una hoja de trucos .

Ejecutemos nuestra aplicación inicial con el siguiente comando.

streamlilt run quickstart.py

Al igual que la aplicación hello, este comando iniciará un nuevo servidor de desarrollo. En su navegador, verá lo siguiente.

Captura de pantalla del autor .

Felicitaciones, acaba de crear su primera aplicación web; sin HTML, CSS y absolutamente sin JavaScript.

Pero esto es rudimentario. Una aplicación web podría hacer muchas cosas interesantes. Podría interactuar con el usuario en tiempo real y actualizar su contenido. Veamos cómo podemos hacerlo.

Agregar interacciones

Traer interacciones en la aplicación web Streamlit es sencillo. La API de Streamlit contiene varios widgets. Puede usarlos para obtener la entrada del usuario y almacenar su valor en una variable. El resto es como cualquier otro programa de Python.

Agreguemos una casilla de verificación para alternar la visualización del conjunto de datos. Después de todo, nadie desarrolla una aplicación web para ver los datos sin procesar. Reemplace la visualización del marco de datos (línea 30) con el siguiente contenido.

# Display the dataframe
df_display = st.checkbox("Display Raw Data", value=True)

if df_display:
    st.write(df)

Fragmento de código del autor .

Si actualiza su navegador, ahora puede ver una casilla de verificación para alternar la visualización del marco de datos.

Captura de pantalla del autor .

Pero un botón de alternar en el medio de la aplicación no es agradable. Vamos a moverlo a una barra lateral.

Agregar una barra lateral a la aplicación

De nuevo, otra acción sin esfuerzo. La API de Streamlit tiene la propiedad de la barra lateral. Todos los widgets que creó en la aplicación principal también están disponibles en esta propiedad de la barra lateral.

Cree una variable de barra lateral usando la propiedad 'st.sidebar'. Luego mueva la asignación de la casilla de verificación que agregamos en la sección principal de la aplicación a la sección de la barra lateral. Observe que ahora usamos 'st.sidebar.checkbox' en lugar de 'st.checkbox'.

# SIDEBAR
# -----------------------------------------------------------
sidebar = st.sidebar
df_display = sidebar.checkbox("Display Raw Data", value=True)

n_clusters = sidebar.slider(
    "Select Number of Clusters",
    min_value=2,
    max_value=10,
)
# -----------------------------------------------------------

Fragmento de código del autor .

En el código anterior, también hemos agregado un control deslizante a la barra lateral. Este widget capturará el número de clústeres seleccionado por el usuario. Así es como se verá la salida.

Captura de pantalla del autor .

En la siguiente parada, ejecutaremos el algoritmo de K medias con el número de clústeres seleccionado por el usuario.

Ejecución de K-Means con entradas en vivo.

Amplíe las importaciones, las funciones auxiliares y las secciones principales de la aplicación con el siguiente código.

# Imports
# -----------------------------------------------------------
...
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_theme()
# -----------------------------------------------------------

# Helper functions
# -----------------------------------------------------------
...
def run_kmeans(df, n_clusters=2):
    kmeans = KMeans(n_clusters, random_state=0).fit(df[["Age", "Income"]])

    fig, ax = plt.subplots(figsize=(16, 9))

    #Create scatterplot
    ax = sns.scatterplot(
        ax=ax,
        x=df.Age,
        y=df.Income,
        hue=kmeans.labels_,
        palette=sns.color_palette("colorblind", n_colors=n_clusters),
        legend=None,
    )

    return fig
# -----------------------------------------------------------

# MAIN APP
# -----------------------------------------------------------
...
# Show cluster scatter plot
st.write(run_kmeans(df, n_clusters=n_clusters))
# -----------------------------------------------------------

Fragmento de código del autor .

En el código anterior, hemos creado una función para ejecutar el algoritmo K-Means. Toma el marco de datos y el número de grupos como argumentos y devuelve una figura de Matplotlib.

La ilustración del agrupamiento de K-Means está más allá del alcance de este proyecto. Es un algoritmo de aprendizaje automático, y eso es lo que nos importa. Pero puede consultar mi publicación anterior que lo describe.

Usamos la variable n_clusters que captura el valor del control deslizante en la sección anterior como el segundo argumento de la función run_forecast.

Si actualiza la página, verá un tablero que toma la entrada del usuario, ejecuta un algoritmo de aprendizaje automático y actualiza instantáneamente la interfaz de usuario.

Captura de pantalla del autor .

Incluso si es un desarrollador experimentado, este nivel de interacción e integración con ML back-end es una tarea difícil. Especialmente si es un científico de datos que no sabe cómo desarrollar aplicaciones web, puede tomar semanas de su tiempo.

 

Mejorar el rendimiento con el almacenamiento en caché.

Algunas tareas en una canalización de ciencia de datos requieren mucho tiempo. Sin embargo, tales tareas rara vez producen resultados diferentes para las mismas entradas. Puede usar las funciones de almacenamiento en caché incorporadas de Streamlit para almacenar sus valores para uso futuro.

Aunque suene complicado, hacerlo con streamlit es sencillo. Su tarea que requiere mucho tiempo debe ser una función, y la envuelve con el decorador @ts .cache. Siempre que los parámetros de entrada sean los mismos y el cuerpo de la función esté intacto, Streamline lo recuperará de la memoria caché.

En la aplicación que creamos, llamamos a la URL externa para descargar datos. Si se trata de una API en vivo, es posible que no desee almacenarla en caché. Pero en nuestro caso, no lo es. Por lo tanto, guardémoslo en caché reemplazando la línea con el siguiente código.

# Load data from external source
@st.cache
def load_data():
    df = pd.read_csv(
        "https://raw.githubusercontent.com/ThuwarakeshM/PracticalML-KMeans-Election/master/voters_demo_sample.csv"
    )
    return df

df = load_data()

Fragmento de código del autor .

En su primera recarga, puede ver un mensaje "Procesando load_data" en su navegador. Pero las recargas posteriores no tendrán esa nota. Esto se debe a que las solicitudes se obtienen del caché en lugar de descargarse de la URL externa.

 

Implementación en Internet

Si ha notado la consola Streamlit, también verá una URL de red. Significa que, si su firewall lo permite, se puede acceder a su aplicación a través de la intranet.

Pero si quieres compartirlo fuera de tu red, tenemos muchas opciones. Como dice la documentación, las aplicaciones Streamlit funcionan en cualquier lugar donde funcione una aplicación de Python.

  1. Streamlit recomienda la opción "Compartir Streamlit".
    Puede poner su código en un repositorio de GitHub y configurar Streamlit Sharing para servir su aplicación.
    Compartir Streamlit es gratis, pero actualmente es solo por invitación. Puedes solicitar una invitación para ti.
  2. Puede implementarlo en plataformas en la nube. Aquí hay un artículo que muestra cómo hacerlo con la instancia gratuita de AWS EC2.
  3. Puede configurar un proxy inverso . Los servidores proxy como Nginx y Apache se pueden configurar para servir la aplicación y restringir el acceso a usuarios específicos.

Asegúrese de leer la guía de la comunidad de Streamlit sobre la implementación para explorar las numerosas opciones disponibles para usted.

Así es como implementé esta aplicación de tutorial en Streamlit Share. Una vez más, Streamlit no dejó de sorprenderme con su conveniencia.

Paso I: coloque su código en un repositorio público de GitHub.
He agregado mi código a este repositorio de GitHub . Necesitamos asegurarnos de que contenga un archivo require.txt con todas las dependencias.

Paso II: Inicie sesión en Streamlit usando su cuenta de GitHub.

Paso III: Cree una nueva aplicación en la consola Streamlit.
Elija su repositorio de git hub del menú desplegable o pasado en la URL. Seleccione la rama que desea usar para la implementación. Finalmente, elija el nombre de archivo principal y haga clic en implementar.

Captura de pantalla del autor.

En aproximadamente un minuto, mi aplicación estará activa en Streamlit Share. Pero el tiempo de implementación puede variar según los requisitos del proyecto.

Tenga en cuenta que el uso compartido optimizado actualmente es solo por invitación. Pero no esperé demasiado para conseguirlo. La documentación de implementación de Streamlit contiene mucha más información útil sobre esto.

 

Conclusión

No hace falta decir que Streamlit resuelve un problema crítico en los proyectos de ciencia de datos. Brinda a los científicos de datos el poder de crear aplicaciones web para interactuar con sus modelos de aprendizaje automático.

En este artículo introductorio, exploramos cómo podemos usar Streamlit con la agrupación en clústeres de K-Means. Aunque es una aplicación trivial, ilustra los conceptos básicos de esta tecnología. Además del desarrollo, también hemos visto cómo administrar el caché para el rendimiento sin esfuerzo en Streamlit. Por último, hablamos sobre las opciones de implementación.

Streamlit es mucho más que esto. Consulte su documentación oficial , que está repleta de excelentes tutoriales. Además, su hoja de trucos API es útil para un desarrollo rápido.

Fuente: https://towardsdatascience.com/how-to-create-stunning-web-apps-for-your-data-science-projects-c7791102134e

#data-science #project 

Crear Impresionantes Web App Para Sus Proyectos De Ciencia De Datos

The Perfect Backend Project For Your Resume! 🏆

The Perfect Backend Project For Your Resume! 🏆

In this video, let's build a real-time backend project together, which uses web sockets for communication. Check out the last video on "Best Backend Projects" (link below) before you get started! 

Timestamps
0:00 Teaser
0:28 Creating a playground
1:32 Initialise the project
3:43 Creating an express app
5:28 Creating Web-socket
26:28 TODO list
28:06 Conclusion
30:13 Outro

Use this playground link for the project:
https://codedamn.com/playground/3q4taTyVOoiEjYZPwuOW7


#backend #project #programming #websocket

The Perfect Backend Project For Your Resume! 🏆
Louis Jones

Louis Jones

1650940698

15 JavaScript Projects for Beginners

Build 15 JavaScript Projects - Vanilla JavaScript Course

Sharpen your JavaScript skills by building 15 projects using plain JavaScript without frameworks. In this tutorial course, you will be taught step-by-step how to build JavaScript projects.

⭐️ Course Contents ⭐️
⌨️ (00:00) Intro
⌨️ (07:01) Color Flipper
⌨️ (30:25) Counter
⌨️ (44:04) Reviews
⌨️ (1:11:29) Navbar
⌨️ (1:26:21) Sidebar
⌨️ (1:39:03) Modal
⌨️ (1:48:26) Questions
⌨️ (2:16:25) Menu
⌨️ (3:16:13) Video
⌨️ (3:32:45) Scroll
⌨️ (4:36:15) Tabs
⌨️ (4:58:53) Countdown
⌨️ (5:56:35) Lorem Ipsum
⌨️ (6:18:23) Grocery
⌨️ (8:01:14) Slider

💻 Code: https://github.com/john-smilga/javascript-basic-projects 
🔗 View completed projects: https://www.vanillajavascriptprojects.com/ 


15 JavaScript projects for beginners

1 - Color Flipper

A background color flipper mini project made with HTML, CSS, and JavaScript.

https://github.com/emjose/color-flipper 

2 - Counter

A small JavaScript project that wires two buttons to count up or count down.

https://github.com/shubhthakre/Counter-Project

3 - Review Carousel

A project of a carousel of reviews, done with HTML, CSS and JavaScript (manipulating the DOM).

https://github.com/javiervaleriano/javier-reviews-carousel

4 - Responsive Navbar

I built a responsive navbar with dropdown using Html, Css and JavaScript

https://github.com/codersgyan/responsive-navbar

5 - Sidebar

Sidebar is a collection of javascript packages distributed via the npm registry. It aims to simplicity and to provide a range of tool that allow users to implement sidebar (or side navs) in their web apps!

https://github.com/ctrlmaniac/sidebar

6 - Modal

Simple modal project with Js and Css

https://github.com/MiladNz/Modal-Project

7 - FAQ Page

An easy to customize template for the FAQ section of your project, with the questions/answers grouped in categories to ease the navigation.

https://github.com/CodyHouse/faq-template

8 - Menu Page

https://github.com/topics/restaurant-website

9 - Digital Clock

A simple and clean digital clock using HTML, JavaScript and CSS.

https://github.com/sabique/Digital-Clock

10 - Scroll Navigation Bar

Uses css to add a class to change the nav bar when the user scrolls up. 

https://github.com/AndrewJBateman/javascript-scroll-navbar

11 - Loan Calculator

A loan calculator built with JavaScript

https://github.com/CBStanley12/js-loan-calculator

12 - Countdown Clock

https://github.com/topics/countdown-clock?l=javascript

13 - Analog Clock

This is a clock that runs on purely JavaScript, HTML, and CSS. It takes an SVG as the basic HTML and CSS layout, then uses CSS animations to rotate the hands on the clock. The JavaScript provides the logic to move the hands according to the number of hours, minutes, and seconds there are in the time of the browser.

https://github.com/dgray0229/javascript-analog-clock

14 - Grocery List

A simple JavaScript shopping list in plain JS

https://github.com/cnstlungu/js-shoppinglist

15 - Image Slider

Quite simply the ideal Image Slider in vanilla JS.

https://github.com/Codeinwp/Ideal-Image-Slider-JS

#javascript #html #css #programming #developer #project

15 JavaScript Projects for Beginners
Tech2 etc

Tech2 etc

1646825446

HTML CSS JavaScript Project | Build Recipe App With HTML CSS JavaScript | Project For Beginners

HTML CSS JavaScript Project | Build Recipe App With HTML CSS JavaScript | Project For Beginners

One of the most popular scripting languages, JavaScript is used in all the web applications for validation, rendering dynamic content, interactive graphics and maps, and much more. Along with HTML and CSS, JS has the power to build complete, robust web applications. Because of JS, the user can interact with a web page and see all the interesting elements on the page. As we explore the projects, we will come to know-how js helps in building interactive web pages. Before that, let us quickly go through the important features of JS:

Used on both client-side and server-side to create interactive web content.

Greatly improves user experience by providing dynamic functionality.

Light-weight language having object-oriented capabilities.

Interpreted, open and cross-platform language.

Seamless integration with Java and HTML.


Why JavaScript Projects?
JS is the heart of any web application. Good knowledge of JavaScript can get you a range of challenging and interesting career options like developing mobile and desktop apps, building dynamic websites from scratch, UI/UX designer, or even a full stack developer. If you know the basics of JavaScript, projects are your next step to add stars to your resume. If you don’t have any prior programming experience, you can take up basic JavaScript courses and then come back to these projects. If you follow a bit of HTML & CSS, you will understand most of the Javascript projects with the source code mentioned below.

For more JavaScript projects visit: https://www.youtube.com/tech2etc

#javascript #project #html #css #web-development 

HTML CSS JavaScript Project | Build Recipe App With HTML CSS JavaScript | Project For Beginners
Tech2 etc

Tech2 etc

1646369561

React JS Project From Scratch | React Website Project | GitHub Profile Fetch Data

React JS Project From Scratch | React Website Project | GitHub Profile Fetch Data

Many React newbies run across this issue once they've mastered the principles of the React library and have progressed to the intermediate stage of learning. Focusing on developing React projects is the best (and probably most productive) approach to move forward.

No, we're not talking about taking on large-scale industry initiatives; instead, we're talking about smaller real-world tasks that can help you put your theoretical knowledge into practice. You can bridge the gap between being a React novice and being a professional developer by working on real-world React projects.

Creating React projects will allow you to hone your React skills while also allowing you to express yourself creatively. However, before we dive into the details of React projects, let's take a look at the "why" and "how" of creating them.

What are the benefits of working on React projects?
I'm sure you've heard the old adage, "practice makes perfect." This is the same situation. After you've mastered the fundamentals of React, you'll want to try your hand at constructing React projects. You will learn how to create functional apps while working on React projects.

Furthermore, as you begin working on React projects, you will learn the tools and React ecosystem to employ for each project. The main benefit of using React to build apps is that once you've successfully launched them, you can add them to your portfolio to impress future employers.

The most difficult part of the process, though, is deciding which React apps to create. We've gathered a collection of React projects for beginners to assist you get started with React project development.

For More Tutorials & Projects Visit Our YouTube Channel: https://www.youtube.com/c/Tech2etc/

#react #app #react-native #javascript #project 

React JS Project From Scratch | React Website Project | GitHub Profile Fetch Data

Microsoft Project Advanced - Full Tutorial

Project Advanced Tutorial

Start 0:00
Introduction 0:03
Start Date 1:17
Saving Baseline 4:28
Tracking Gantt View 6:30
Percent Complete 10:25
Actual Start-Finish 13:43
Adjusting Work Assignments 16:50
Rescheduling Started Tasks 20:14
Organizer 23:28
Filter Tasks 25:40
Reports 28:19
Sharing Resources 31:20
Master Projects 35:33
Adding Columns 38:19
Custom Field Pull Downs 39:58
Level Delay Calculations 42:20
Time to Practice 48:01

#project #Microsoft 

Microsoft Project Advanced - Full Tutorial

Microsoft Project - Full Tutorial For Beginners

Project Beginner Tutorial

Start: 0:00
Introduction 0:03
An Important First Step 3:06
Touring the Software 6:44
Tasks and Phases 11:44
Task Durations 18:15
Decomposing Tasks 25:29
Notes, Hyperlinks, and Estimates 27:30
Linking Tasks 32:29
Linking Extras 37:49
Lag Time 40:58
Understanding Non-Standard Relationships 44:24
Creating Non-Standard Links 47:52
Start to Finish Relationships 54:14
Start Dates and Deadline Timing 1:00:35
Manually Scheduling Tasks 1:01:28
Start Date with Constraints 1:06:05
Setting Deadlines with Constraints 1:14:59
Applying What We've Learned 1:17:37
Working with Calendars 1:20:24
Creating Calendars 1:24:50
Setting a Start Date 1:27:18
Another Important Rule and Setup 1:29:51
Creating Resource Sheets 1:32:02
Editing Resources 1:37:14
Assigning Resources 1:39:26
Changing Work Assignments 1:42:30
Resource List Options 1:45:14
Fixing Over-Allocations by Hand 1:47:26
Level Resources 1:50:12
Cheat Sheet and Recommendations 1:56:21

#project #microsoft 

Microsoft Project - Full Tutorial For Beginners