Forem: Bogusdeck

MONGOdb 🍃 in python project!

Bogusdeck — Fri, 26 Jul 2024 11:19:27 +0000

Introduction

PyMongo is a Python driver for MongoDB, a popular NoSQL database. MongoDB is a document-oriented database that stores data in flexible, JSON-like documents, and PyMongo allows Python applications to interact with MongoDB.

With PyMongo, you can perform various database operations, such as inserting, updating, deleting, and querying documents. It provides a convenient and Pythonic way to work with MongoDB, allowing you to use Python data structures and idioms directly.

Creating a Database

Install PyMongo

pip install pymongo

Connect to MongoDB

import pymongo

# Connect to MongoDB server (default: localhost, port: 27017)
client = pymongo.MongoClient("mongodb://localhost:27017/")

Create or Select a Database

# Create or select a database
mydatabase = client["mydatabase"]

Create or Select a Collection

# Create or select a collection
mycollection = mydatabase["mycollection"]

Sort the Result

Use the sort() method to sort the result in ascending or descending order.

The sort() method takes one parameter for "field name" and one parameter for "direction" (ascending is the default direction)

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

mydoc = mycol.find().sort("name") #for descending .sort("name",-1)

for x in mydoc:
  print(x)

Insertion

Insert Documents

# Insert a single document
document = {"name": "John", "age": 30, "city": "New York"}
result = mycollection.insert_one(document)
print(f"Inserted document ID: {result.inserted_id}")

Insert Multiple Documents

# Insert multiple documents
documents = [
    {"name": "Alice", "age": 25, "city": "San Francisco"},
    {"name": "Bob", "age": 35, "city": "Los Angeles"}
]
result = mycollection.insert_many(documents)
print(f"Inserted {len(result.inserted_ids)} documents")

Deletion

Delete one document

# Delete a document
mycollection.delete_one({"name": "John"})

Delete multiple documents

# Delete multiple documents
mycollection.delete_many({"city": "Brooklyn"})

Delete all documents in a collections

x = mycol.delete_many({})

print(x.deleted_count, " documents deleted.")

Delete a collection

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

mycol.drop()

Updation

Update a single documents

# Update a document
mycollection.update_one({"name": "John"}, {"$set": {"age": 31}})

alternate method

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

myquery = { "address": "Valley 345" }
newvalues = { "$set": { "address": "Canyon 123" } }

mycol.update_one(myquery, newvalues)

#print "customers" after the update:
for x in mycol.find():
  print(x)

Update multiple documents

# Update multiple documents
mycollection.update_many({"city": "New York"}, {"$set": {"city": "Brooklyn"}})

Searching a query

To select data from a collection in MongoDB, we can use the find_one() method.

The find_one() method returns the first occurrence in the selection.

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

x = mycol.find_one()

print(x)

To select data from a table in MongoDB, we can also use the find() method.

The find() method returns all occurrences in the selection.

The first parameter of the find() method is a query object. In this example we use an empty query object, which selects all documents in the collection.

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

for x in mycol.find():
  print(x)

using second parameter in find()

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

for x in mycol.find({},{ "_id": 0, "name": 1, "address": 1 }):
  print(x)

Filter the result

When finding documents in a collection, you can filter the result by using a query object.

The first argument of the find() method is a query object, and is used to limit the search.

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

myquery = { "address": "Park Lane 38" }

mydoc = mycol.find(myquery)

for x in mydoc:
  print(x)

Advance query

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

myquery = { "address": { "$gt": "S" } }

mydoc = mycol.find(myquery)

for x in mydoc:
  print(x)

Limit the query result

import pymongo

myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
mycol = mydb["customers"]

myresult = mycol.find().limit(5)

#print the result:
for x in myresult:
  print(x)

Setup for flask with tailwind project

Bogusdeck — Tue, 12 Mar 2024 15:06:44 +0000

how to setup tailwind css with flask app

status: ✏️ Draft
categories: Coding, Javascript, flask, python, webdev
published: 12/03/2024
Author: tanish vashisth
route: tutorial

Simplicity is the cornerstone of efficient web development. In this blog post, we'll explore the seamless integration of Flask, a lightweight Python web framework, with Tailwind CSS, a utility-first CSS framework. By combining these two powerful tools, developers can effortlessly create sleek and responsive web applications with minimal setup. Join us as we unveil the essentials of setting up a Flask and Tailwind project, empowering you to embark on your web development journey with ease and finesse.

Setting up a Flask project with Tailwind CSS involves several steps. Here's a basic guide to get you started:

Install Flask :

First, you need to have Flask installed. You can install it via pip:
```
pip install Flask
```
Create a Flask project directory :

Create a directory for your Flask project.
Initialize a virtual environment (optional but recommended) :

Navigate to your project directory and create a virtual environment to isolate your project dependencies.
```
python3 -m venv venv
```
Activate the virtual environment :
- On Windows:
```
.venv\Scripts\activate
```

- On macOS/Linux:

```
source venv/bin/activate
```

Start an npm project :

We need this to automatically compile our tailwindcss file to make sure only the tailwind classes we are using are included in the output.css file
```
npm init -y
```
Initialize Tailwind CSS :

Initialize Tailwind CSS in your project directory. This will create a tailwind.config.js file and a tailwind.css file.
```
npx i tailwindcss
```
now we need to initialise tailwindcss
```
npx tailwindcss init
```
Add content in tailwind.config.js :

we need to add the path of our templates files inside tailwind.config.js

/** @type {import('tailwindcss').Config} **/
module.exports = {
content: ["./templates/*.html"],
theme: {
extend: {},
},
plugins: [],
}

Create input.css file :

Now create a CSS file which will contain the base code of tailwindcss.

create the file inside “/static/css/input.css”

Enter the following code inside input.css

@tailwind base;
@tailwind components;
@tailwind utilities;

Start the build process :

We will now run a command that will take the input.css file as input and generate the output CSS which will only contain the tailwind classes required by our html files

now run this command on a new terminal :

npx tailwindcss -i ./static/css/input.css -o ./static/css/output.css --watch

Add the output.css :

This command instructs Tailwind to create an "output.css" file containing only the utility classes utilized within the HTML files located in your "templates" folder. You can then include the generated file "./static/css/output.css" in your HTML files using the specified command.

<link href="{{url_for('static',filename='css/output.css')}}" rel="stylesheet">

Test your project :

Add the below code inside the index.html file

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link href="{{url_for('static',filename='css/output.css')}}" rel="stylesheet">
    <title>Document</title>
</head>
<body>
    <div class="bg-red-600">
        background is red
    </div>
</body>
</html>

Create app.py file in your root directory :

from flask import Flask, render_template

app = Flask(__name__)

@app.route("/")
def hello_world():
    return render_template("index.html")

app.run(debug=True)

Run the flask app:
```
python main.py
```

Now, you should have a Flask project set up with Tailwind CSS integrated. Access your Flask application in a web browser by navigating to http://localhost:5000/.

How to change the apperance of your terminal

Bogusdeck — Wed, 20 Dec 2023 11:44:15 +0000

Kitty Terminal Configuration

more screenshot

This repository contains my personal configuration for the Kitty terminal emulator, tailored to enhance my development workflow and make the terminal experience more enjoyable. Kitty is a fast, feature-rich, GPU-accelerated terminal emulator.

Installation

Install Kitty Terminal:

If you haven't installed Kitty yet, follow the official installation instructions.

Clone this Repository:

   git clone https://github.com/Prome-theus/Kitty-dotfiles

Copy Configuration Files:

Navigate to the cloned directory and copy the configuration files to the appropriate locations:

   cp kitty.conf ~/.config/kitty/
   cp tanish.omp.json ~/.config/kitty

Restart Kitty Terminal:

Restart the Kitty terminal for the changes to take effect.

Install OMP(OH_MY_POSH):

installation guide OMP

for arch linux :

   yay -S oh-my-posh

for windows

   winget install JanDeDobbeleer.OhMyPosh -s winget

Install fonts:(optional)

VictorMono Nerd Font.

Activate Oh-my-posh :

   oh-my-posh init

than install font

   oh-my-posh font install

select VictorMono nerd font

Copy the config files:

   cp -f config.fish ~/.config/fish/

Enjoy using the Kitty terminal with this configuration! If you find it helpful, don't forget to give it a star. Happy coding! 🚀

EASY GIT

Bogusdeck — Fri, 15 Dec 2023 11:26:57 +0000

Git Cheat Sheet: A Quick Reference Guide

$ git config --global user.name "Your Name"

Assign Your Email

$ git config --global user.email xyz@domain.com

Initialization

Initialize Git in Your Folder

$ git init

Show Git Status

$ git status

Basic Commands

Add File to Staging Area

$ git add index.html

Commit File

$ git commit

Commit with Message

$ git commit -m "Added more HTMLs"

Send All Files to Staging Area

$ git add -A

Recover File or Match Last Commit

$ git checkout index.html

Recover All Files

$ git checkout -f

Viewing Commits

View Commit Log

$ git log

Filter Commit Log

$ git log -p (number of commits)

Comparisons

Working Tree and Staging Area

$ git diff

Compare Last Commit to Staging Area

$ git diff --staged

Advanced Committing

Commit All Files Directly

$ git commit -a -m "Skipped staging area and fixed"

Remove File from Directory and Staging Area

$ git rm about.html

Remove File from Staging Area

$ git rm --cached about.html

Show Staging and Working Tree Status

$ git status -s

Remote Repositories

Add Remote Repo (Origin)

$ git remote add origin https://github.com/Prome-theus/CSES.git

Get Remote Repo Links

$ git remote -v

Push to Remote Repo (Origin - Master Branch)

$ git push origin master

Change Remote Repo URL

$ git remote set-url origin git@github.com:Prome-theus/CSES.git

Push to Remote Repo with Default Branch Set

$ git push -u origin master

Clone a Repository

$ git clone {url}

Branching

Create a New Branch

$ git branch feature1

Show All Branches

$ git branch

Switch Branch

$ git checkout feature1

Merge Branch to Master

$ git merge feature1

Create and Switch to a New Branch

$ git checkout -b htmlcodes

Git Ignore

Create a .gitignore file in your directory to specify files you want to ignore in the repository.

For example:

mylogs.log
*.log
/mylogs.log
ignore/

Remember to add and commit the .gitignore file to your repository.

Branching Note

The master branch is typically considered the main branch.

This cheat sheet covers essential Git commands, but feel free to explore more features and options in the official Git cheatsheet. Happy coding!

Django 5.0 is here

Bogusdeck — Thu, 07 Dec 2023 04:24:38 +0000

Django 5.0 is released 🎉🎉🎉

Lot of exiting changes to DjangoORM and more..

Let's take a brief look at what's new.

Generated fields

The new GeneratedField enables the creation of database-generated fields, where values are automatically computed by the database itself based on other fields (and indexable too). For example, if you have first_name and last_name fields, you can use a GeneratedField to create a full_name property that is a combination of the two, allowing the database to handle the generation process.

Database-computed default values

This was the last significant obstacle to fully representing the structure of Django models in the database schema. In Django versions prior to 5.0, the only option for setting a default value for a field was through Field.default, and it was calculated on the Python side, not in the database. The new Field.db_default option addresses this limitation by allowing the creation of default values directly in the database schema, providing a valuable improvement for consistency

Form field group rendering

The new concept of form field group rendering makes field rendering simpler and more reusable. Now you can use filed.as_field_group to render separate fields without any inconsistencies.

Host your website locally to show everyone

Bogusdeck — Tue, 05 Dec 2023 03:12:07 +0000

Have you ever wanted to share a website you're developing on your local machine with someone else? Or perhaps you need to demo a project to a client or a colleague without deploying it to a public server? This is where LocalTunnel comes to the rescue. In this guide, we'll walk through the steps of using LocalTunnel to expose your locally hosted website to the internet, making it accessible to anyone, anywhere

What is LocalTunnel?

LocalTunnel is a powerful tool that allows you to expose your local development server to the internet. It creates a secure tunnel to a public URL, enabling others to access your locally hosted website as if it were live on the web.

Let's Setup

Install nodejs and npm in your system

For Windows and mac OS
nodejs.org

For Linux

Ubuntu/debian

sudo apt update
sudo apt install nodejs npm

Arch linux
```
sudo pacman -S nodejs npm
```

Install local tunnel

Open your terminal and run the following command to install localtunnel globally

npm install -g localtunnel

Start your Local Server

start your application or website on local development server

Use localtunnel

In your Terminal , run the following command

lt --port <your_local_port>

For example
if website or application is hosted on local host i.e port 3000

lt --port 3000

LocalTunnel will generate a unique URL which you can share with others to access your locally hosted website

Some advance options

Custom Subdomain

lt --port <your_local_port> --subdomain <your_custom_subdomain>

Allowing specific hostnames

lt --port <your_local_port> --host <allowed_hostname>

Setting Maximum Connections

lt --port <your_local_port> --max-conn 3

Specifying Base Domain

lt --port <your_local_port> --domain <your_domain>

💡 Be mindful when using LocalTunnel, as it's convenient but may pose security risks. Avoid exposing sensitive information, and make certain your local server is secure, preventing any inadvertent exposure of confidential data to the public.

MongoDB learning Guide

Bogusdeck — Sat, 02 Dec 2023 12:31:03 +0000

Certainly! If you're creating tutorial notes on MongoDB, you might want to cover a broader range of topics. Here's an outline for creating tutorial notes:

1. Introduction to MongoDB

What is MongoDB?
How does MongoDB differ from traditional relational databases?
Key features and advantages of MongoDB.

2. Installation and Setup

Downloading and installing MongoDB.
Starting and stopping the MongoDB server.
Connecting to MongoDB through the shell.

3. Basic MongoDB Concepts

Databases and Collections.
BSON (Binary JSON) format.
Documents and Fields.

4. CRUD Operations

Creating a Database.
Creating Collections.
Inserting Documents.
Querying Documents.
Updating Documents.
Deleting Documents.

5. Data Modeling

Schemaless design.
Embedding vs. Referencing.
Design considerations for various use cases.

6. Indexing

Importance of indexes.
Creating and managing indexes.
Index types and their impact on performance.

7. Aggregation Framework

Introduction to the Aggregation Framework.
Pipeline stages for data transformation.
Aggregation operators.

8. Working with Date and Time

Date and time data types.
Date and time operators and functions.

9. Security

Authentication and Authorization.
User roles and privileges.
Best practices for securing MongoDB.

10. Scaling and Sharding

Horizontal scaling with sharding.
Sharding strategies.
Monitoring and managing a sharded cluster.

11. Backing Up and Restoring

Database backup strategies.
Restoring data from backups.

12. Using MongoDB with Programming Languages

MongoDB drivers for various programming languages.
Connecting and interacting with MongoDB in a programming language (e.g., Python, Node.js).

13. Case Studies and Best Practices

Real-world examples of MongoDB implementations.
Best practices for optimal performance.
Common pitfalls and how to avoid them.

14. Advanced Topics

Transactions in MongoDB.
Geospatial data and queries.
Full-text search.

15. Resources and Further Learning

MongoDB official documentation.
Online courses and tutorials.
Community forums and support.

Additional Tips:

Include code examples and snippets for each concept.
Provide exercises or challenges for hands-on practice.
Use visuals like diagrams or charts to explain complex concepts.
Regularly update your tutorial notes to keep them current with the latest MongoDB features and best practices.

Enjoy Mongo!

Use Spotify made for Developers

Bogusdeck — Fri, 01 Dec 2023 19:35:03 +0000

Launch Spotify directly from your terminal for a streamlined experience without the need for a resource-intensive browser tab or desktop application. Just follow these straightforward steps, and you'll be enjoying your music in no time.

Installation

To install the spotify-tui client from Rigellute/spotify-tui
github repository or you can use different methods depending on your OS{macOS, Arch linux}

For MAC installation

brew install spotify-tui
brew install spotifyd
brew services start spotifyd

For arch linux

yay -S spotify-tui
yay -S spotifyd

we also need to install Spotifyd, a lightweight Unix daemon, you’ll get a fully-featured terminal application that connects to your Spotify Premium account.

Configuration

Create a configuration file

~/.config/spotifyd/spotifyd.conf:

[global]
# Your Spotify account name.
username = "{your spotify username}"

# Your Spotify account password.
password = "Launch Spotify directly from your terminal for a streamlined experience without the need for a resource-intensive browser tab or desktop application. Just follow these straightforward steps, and you'll be enjoying your music in no time.

## Installation
To install the spotify-tui client from Rigellute/spotify-tui
github repository or you can use different methods depending on your OS{macOS, Arch linux}

> For MAC installation

brew install spotify-tui
brew install spotifyd
brew services start spotifyd

> For arch linux

yay -S spotify-tui
yay -S spotifyd


we also need to install Spotifyd, a lightweight Unix daemon, you’ll get a fully-featured terminal application that connects to your Spotify Premium account.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zecf2s93n8fp3pot171w.png)

## Configuration
### Create a configuration file
`~/.config/spotifyd/spotifyd.conf:`

[global]

Your Spotify account name.

username = "{your spotify username}"

Your Spotify account password.

password = "Launch Spotify directly from your terminal for a streamlined experience without the need for a resource-intensive browser tab or desktop application. Just follow these straightforward steps, and you'll be enjoying your music in no time.

Installation

To install the spotify-tui client from Rigellute/spotify-tui
github repository or you can use different methods depending on your OS{macOS, Arch linux}

For MAC installation

brew install spotify-tui
brew install spotifyd
brew services start spotifyd

For arch linux

yay -S spotify-tui
yay -S spotifyd

we also need to install Spotifyd, a lightweight Unix daemon, you’ll get a fully-featured terminal application that connects to your Spotify Premium account.

Configuration

Create a configuration file

~/.config/spotifyd/spotifyd.conf:

[global]
# Your Spotify account name.
username = "{your spotify username}"

# Your Spotify account password.
password = "Launch Spotify directly from your terminal for a streamlined experience without the need for a resource-intensive browser tab or desktop application. Just follow these straightforward steps, and you'll be enjoying your music in no time.

## Installation
To install the spotify-tui client from Rigellute/spotify-tui
github repository or you can use different methods depending on your OS{macOS, Arch linux}

> For MAC installation

brew install spotify-tui
brew install spotifyd
brew services start spotifyd

> For arch linux

yay -S spotify-tui
yay -S spotifyd


we also need to install Spotifyd, a lightweight Unix daemon, you’ll get a fully-featured terminal application that connects to your Spotify Premium account.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zecf2s93n8fp3pot171w.png)

## Configuration
### Create a configuration file 
`~/.config/spotifyd/spotifyd.conf:`

[global]

Your Spotify account name.

username = "{your spotify username}"

Your Spotify account password.

Installation

To install the spotify-tui client from Rigellute/spotify-tui
github repository or you can use different methods depending on your OS{macOS, Arch linux}

For MAC installation

brew install spotify-tui
brew install spotifyd
brew services start spotifyd

For arch linux

yay -S spotify-tui
yay -S spotifyd

we also need to install Spotifyd, a lightweight Unix daemon, you’ll get a fully-featured terminal application that connects to your Spotify Premium account.

Configuration

Create a configuration file

~/.config/spotifyd/spotifyd.conf:

[global]
# Your Spotify account name.
username = "{your spotify username}"

# Your Spotify account password.
password = "pass spotify/spotifyd"

use_keyring = true
use_mpris = true
dbus_type = "session"
backend = "alsa" # use portaudio for macOS [homebrew]
device = "alsa_audio_device"  # omit for macOS
audio_format = "S16"
control = "alsa_audio_device"  # omit for macOS
mixer = "PCM"  # omit for macOS
volume_controller = "alsa"  # use softvol for macOS
on_song_change_hook = "command_to_run_on_playback_events"
device_name = "spotifyd"
bitrate = 320
cache_path = ""/Users/<your Username>/.cache/spotifyd"
max_cache_size = 1000000000
no_audio_cache = true
initial_volume = "90"
volume_normalisation = true
normalisation_pregain = -10
autoplay = true
zeroconf_port = 1234
proxy = "http://proxy.example.org:8080"
audio_dongle.
device_type = "computer"

fill your username, password and your system username in username, password and cache_path respectively

Create a systemd user script

~/.config/systemd/user/spotifyd.service:

[Unit]

Description=A spotify playing daemon

Documentation=https://github.com/Spotifyd/spotifyd

Wants=sound.target

After=sound.target

Wants=network-online.target

After=network-online.target

[Service]

ExecStart=/usr/bin/spotifyd --no-daemon

Restart=always

RestartSec=12

[Install]

WantedBy=default.target

Then enable and start the script

systemctl --user enable spotifyd --now

Connecting to Spotify API

To connect Spotify-tui to Spotify's API for music playback and track searching, follow these steps:

Visit the Spotify dashboard.
Create a new app to obtain your Client ID and Client Secret.
Edit app settings and add http://localhost:8888/callback as a Redirect URI.
Save settings and return to the terminal.
Run "spt" and enter your Client ID and Client Secret when prompted.
Confirm the default port (8888) or input a custom port.
You'll be redirected to Spotify for permission.
After approval, the redirect URL is automatically parsed.
If the local web server fails, copy the URL from the blank page and paste it into the terminal prompt.
You're now ready to use spotify-tui! 🎉

After you’ve run spt for the first time, you’ll find a configuration file under ~/.config/spotify-tui/client.yml

Connect with spotifyd

Make sure that spotifyd.service is running:

systemctl --user status spotifyd.service

Now, run spt in terminal and select any song
and press ENTER

If Spotify TUI indicates it can't find a device, press 'd', and the CLI will display the available Spotifyd clients. Select the appropriate one by pressing 'Enter'.

Now it should Work.

Enjoy Listening

use_keyring = true

use_mpris = true

dbus_type = "session"

backend = "alsa" # use portaudio for macOS [homebrew]

device = "alsa_audio_device"  # omit for macOS

audio_format = "S16"

control = "alsa_audio_device"  # omit for macOS

mixer = "PCM"  # omit for macOS

volume_controller = "alsa"  # use softvol for macOS

on_song_change_hook = "command_to_run_on_playback_events"

device_name = "spotifyd"

bitrate = 320

cache_path = ""/Users/<your Username>/.cache/spotifyd"

max_cache_size = 1000000000

no_audio_cache = true

initial_volume = "90"

volume_normalisation = true

normalisation_pregain = -10

autoplay = true

zeroconf_port = 1234

proxy = "http://proxy.example.org:8080"

audio_dongle.

device_type = "computer"

Create a systemd user script

~/.config/systemd/user/spotifyd.service:

[Unit]

Description=A spotify playing daemon

Documentation=https://github.com/Spotifyd/spotifyd

Wants=sound.target

After=sound.target

Wants=network-online.target

After=network-online.target

[Service]

ExecStart=/usr/bin/spotifyd --no-daemon

Restart=always

RestartSec=12

[Install]

WantedBy=default.target

Then enable and start the script

systemctl --user enable spotifyd --now

Connecting to Spotify API

To connect Spotify-tui to Spotify's API for music playback and track searching, follow these steps:

Visit the Spotify dashboard.
Create a new app to obtain your Client ID and Client Secret.
Edit app settings and add http://localhost:8888/callback as a Redirect URI.
Save settings and return to the terminal.
Run "spt" and enter your Client ID and Client Secret when prompted.
Confirm the default port (8888) or input a custom port.
You'll be redirected to Spotify for permission.
After approval, the redirect URL is automatically parsed.
If the local web server fails, copy the URL from the blank page and paste it into the terminal prompt.
You're now ready to use spotify-tui! 🎉

After you’ve run spt for the first time, you’ll find a configuration file under ~/.config/spotify-tui/client.yml

Connect with spotifyd

Make sure that spotifyd.service is running:

systemctl --user status spotifyd.service

Now, run spt in terminal and select any song
and press ENTER

If Spotify TUI indicates it can't find a device, press 'd', and the CLI will display the available Spotifyd clients. Select the appropriate one by pressing 'Enter'.

Now it should Work.

Enjoy Listening

use_keyring = true

use_mpris = true

dbus_type = "session"

backend = "alsa" # use portaudio for macOS [homebrew]

device = "alsa_audio_device"  # omit for macOS

audio_format = "S16"

control = "alsa_audio_device"  # omit for macOS

mixer = "PCM"  # omit for macOS

volume_controller = "alsa"  # use softvol for macOS

on_song_change_hook = "command_to_run_on_playback_events"

device_name = "spotifyd"

bitrate = 320

cache_path = ""/Users/<your Username>/.cache/spotifyd"

max_cache_size = 1000000000

no_audio_cache = true

initial_volume = "90"

volume_normalisation = true

normalisation_pregain = -10

autoplay = true

zeroconf_port = 1234

proxy = "http://proxy.example.org:8080"

audio_dongle.

device_type = "computer"

Create a systemd user script

~/.config/systemd/user/spotifyd.service:

[Unit]

Description=A spotify playing daemon

Documentation=https://github.com/Spotifyd/spotifyd

Wants=sound.target

After=sound.target

Wants=network-online.target

After=network-online.target

[Service]

ExecStart=/usr/bin/spotifyd --no-daemon

Restart=always

RestartSec=12

[Install]

WantedBy=default.target

Then enable and start the script

systemctl --user enable spotifyd --now

Connecting to Spotify API

To connect Spotify-tui to Spotify's API for music playback and track searching, follow these steps:

Visit the Spotify dashboard.
Create a new app to obtain your Client ID and Client Secret.
Edit app settings and add http://localhost:8888/callback as a Redirect URI.
Save settings and return to the terminal.
Run "spt" and enter your Client ID and Client Secret when prompted.
Confirm the default port (8888) or input a custom port.
You'll be redirected to Spotify for permission.
After approval, the redirect URL is automatically parsed.
If the local web server fails, copy the URL from the blank page and paste it into the terminal prompt.
You're now ready to use spotify-tui! 🎉

After you’ve run spt for the first time, you’ll find a configuration file under ~/.config/spotify-tui/client.yml

Connect with spotifyd

Make sure that spotifyd.service is running:

systemctl --user status spotifyd.service

Now, run spt in terminal and select any song
and press ENTER

If Spotify TUI indicates it can't find a device, press 'd', and the CLI will display the available Spotifyd clients. Select the appropriate one by pressing 'Enter'.

Now it should Work.

Enjoy Listening

use_keyring = true

use_mpris = true

dbus_type = "session"

backend = "alsa" # use portaudio for macOS [homebrew]

device = "alsa_audio_device"  # omit for macOS

audio_format = "S16"

control = "alsa_audio_device"  # omit for macOS

mixer = "PCM"  # omit for macOS

volume_controller = "alsa"  # use softvol for macOS

on_song_change_hook = "command_to_run_on_playback_events"

device_name = "spotifyd"

bitrate = 320

cache_path = ""/Users/<your Username>/.cache/spotifyd"

max_cache_size = 1000000000

no_audio_cache = true

initial_volume = "90"

volume_normalisation = true

normalisation_pregain = -10

autoplay = true

zeroconf_port = 1234

proxy = "http://proxy.example.org:8080"

audio_dongle.

device_type = "computer"

Create a systemd user script

~/.config/systemd/user/spotifyd.service:

[Unit]

Description=A spotify playing daemon

Documentation=https://github.com/Spotifyd/spotifyd

Wants=sound.target

After=sound.target

Wants=network-online.target

After=network-online.target

[Service]

ExecStart=/usr/bin/spotifyd --no-daemon

Restart=always

RestartSec=12

[Install]

WantedBy=default.target

Then enable and start the script

systemctl --user enable spotifyd --now

Connecting to Spotify API

To connect Spotify-tui to Spotify's API for music playback and track searching, follow these steps:

Visit the Spotify dashboard.
Create a new app to obtain your Client ID and Client Secret.
Edit app settings and add http://localhost:8888/callback as a Redirect URI.
Save settings and return to the terminal.
Run "spt" and enter your Client ID and Client Secret when prompted.
Confirm the default port (8888) or input a custom port.
You'll be redirected to Spotify for permission.
After approval, the redirect URL is automatically parsed.
If the local web server fails, copy the URL from the blank page and paste it into the terminal prompt.
You're now ready to use spotify-tui! 🎉

After you’ve run spt for the first time, you’ll find a configuration file under ~/.config/spotify-tui/client.yml

Connect with spotifyd

Make sure that spotifyd.service is running:

systemctl --user status spotifyd.service

Now, run spt in terminal and select any song
and press ENTER

If Spotify TUI indicates it can't find a device, press 'd', and the CLI will display the available Spotifyd clients. Select the appropriate one by pressing 'Enter'.

Now it should Work.

Enjoy Listening

use_keyring = true

use_mpris = true

dbus_type = "session"

backend = "alsa" # use portaudio for macOS [homebrew]

device = "alsa_audio_device"  # omit for macOS

audio_format = "S16"

control = "alsa_audio_device"  # omit for macOS

mixer = "PCM"  # omit for macOS

volume_controller = "alsa"  # use softvol for macOS

on_song_change_hook = "command_to_run_on_playback_events"

device_name = "spotifyd"

bitrate = 320

cache_path = ""/Users/<your Username>/.cache/spotifyd"

max_cache_size = 1000000000

no_audio_cache = true

initial_volume = "90"

volume_normalisation = true

normalisation_pregain = -10

autoplay = true

zeroconf_port = 1234

proxy = "http://proxy.example.org:8080"

audio_dongle.

device_type = "computer"

Create a systemd user script

~/.config/systemd/user/spotifyd.service:

[Unit]

Description=A spotify playing daemon

Documentation=https://github.com/Spotifyd/spotifyd

Wants=sound.target

After=sound.target

Wants=network-online.target

After=network-online.target

[Service]

ExecStart=/usr/bin/spotifyd --no-daemon

Restart=always

RestartSec=12

[Install]

WantedBy=default.target

Then enable and start the script

systemctl --user enable spotifyd --now

Connecting to Spotify API

To connect Spotify-tui to Spotify's API for music playback and track searching, follow these steps:

Visit the Spotify dashboard.
Create a new app to obtain your Client ID and Client Secret.
Edit app settings and add http://localhost:8888/callback as a Redirect URI.
Save settings and return to the terminal.
Run "spt" and enter your Client ID and Client Secret when prompted.
Confirm the default port (8888) or input a custom port.
You'll be redirected to Spotify for permission.
After approval, the redirect URL is automatically parsed.
If the local web server fails, copy the URL from the blank page and paste it into the terminal prompt.
You're now ready to use spotify-tui! 🎉

After you’ve run spt for the first time, you’ll find a configuration file under ~/.config/spotify-tui/client.yml

Connect with spotifyd

Make sure that spotifyd.service is running:

systemctl --user status spotifyd.service

Now, run spt in terminal and select any song
and press ENTER

If Spotify TUI indicates it can't find a device, press 'd', and the CLI will display the available Spotifyd clients. Select the appropriate one by pressing 'Enter'.

Now it should Work.

Enjoy Listening