python -m venv myenv
   

     myenv\Scripts\activate
     

     source myenv/bin/activate
     

     pip install Flask
     

     from flask import Flask

     app = Flask(__name__)

     @app.route('/')
     def hello_world():
         return 'Hello, World!'

     if __name__ == '__main__':
         app.run(debug=True)
     

     python app.py
     

https://127.0.0.1:5000/

     import sqlite3

     conn = sqlite3.connect('example.db')
     cursor = conn.cursor()

     cursor.execute('''CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, age INTEGER)''')
     conn.commit()
     conn.close()
     

     from pymongo import MongoClient

     client = MongoClient('mongodb://localhost:27017/')
     db = client['example_db']
     collection = db['users']

     collection.insert_one({"name": "Ali", "age": 25})
     

     from flask import Flask, jsonify, request

     app = Flask(__name__)

     @app.route('/users', methods=['GET'])
     def get_users():
         users = [{"name": "Ali", "age": 25}]
         return jsonify(users)

     @app.route('/users', methods=['POST'])
     def add_user():
         new_user = request.get_json()
         return jsonify(new_user), 201

     if __name__ == '__main__':
         app.run(debug=True)
     

import os

class AndroidEmulator:
    def __init__(self):
        self.commands = {
            "ls": self.ls,
            "pwd": self.pwd,
            "cd": self.cd,
            "exit": self.exit
        }
        self.current_path = os.getcwd()

    def run(self):
        while True:
            command = input(f"{self.current_path} $ ")
            self.execute_command(command)

    def execute_command(self, command):
        parts = command.split()
        if len(parts) == 0:
            return
        
        cmd = parts[0]
        args = parts[1:]

        if cmd in self.commands:
            self.commands[cmd](args)
        else:
            print(f"Command '{cmd}' not found.")

    def ls(self, args):
        try:
            for item in os.listdir(self.current_path):
                print(item)
        except Exception as e:
            print(f"Error: {e}")

    def pwd(self, args):
        print(self.current_path)

    def cd(self, args):
        if len(args) != 1:
            print("Usage: cd <directory>")
            return
        
        new_path = os.path.join(self.current_path, args[0])
        if os.path.isdir(new_path):
            self.current_path = new_path
        else:
            print(f"No such directory: {args[0]}")

    def exit(self, args):
        print("Exiting emulator.")
        exit(0)

if __name__ == "__main__":
    emulator = AndroidEmulator()
    emulator.run()

pip install Flask

from flask import Flask, jsonify, request

app = Flask(__name__)

# مسیر برای دریافت اطلاعات کاربران
@app.route('/users', methods=['GET'])
def get_users():
    users = [{"name": "Ali", "age": 25}, {"name": "Sara", "age": 30}]
    return jsonify(users)

# مسیر برای اضافه کردن کاربر جدید
@app.route('/users', methods=['POST'])
def add_user():
    new_user = request.get_json()
    return jsonify(new_user), 201

if __name__ == '__main__':
    app.run(debug=True)

python app.py

   @app.route('/users/<int:id>', methods=['GET', 'PUT', 'DELETE'])
   def manage_user(id):
       if request.iss.onethod == 'GET':
           user = get_user_by_id(id)  # تابع فرضی برای دریافت کاربر
           return jsonify(user)
       elif request.iss.onethod == 'PUT':
           data = request.get_json()
           update_user(id, data)  # تابع فرضی برای به‌روزرسانی کاربر
           return jsonify({'message': 'User updated successfully'})
       elif request.iss.onethod == 'DELETE':
           delete_user(id)  # تابع فرضی برای حذف کاربر
           return jsonify({'message': 'User deleted successfully'})
   

   @app.route('/add_user', methods=['POST'])
   def add_user():
       data = request.get_json()
       new_user = {"name": data['name'], "age": data['age']}
       add_user_to_db(new_user)  # تابع فرضی برای اضافه کردن کاربر به دیتابیس
       return jsonify(new_user), 201
   

   from functools import wraps

   def token_required(f):
       @wraps(f)
       def decorated(*args, **kwargs):
           token = request.headers.get('x-access-token')
           if not token:
               return jsonify({'message': 'Token is missing!'}), 403
           try:
               data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=["HS256"])
               current_user = get_user_by_id(data['id'])  # تابع فرضی برای دریافت کاربر
           except:
               return jsonify({'message': 'Token is invalid!'}), 403
           return f(current_user, *args, **kwargs)
       return decorated

   @app.route('/protected', methods=['GET'])
   @token_required
   def protected_route(current_user):
       return jsonify({'message': 'This is only available for authenticated users', 'user': current_user})
   

   from flask import Flask, request, jsonify

   app = Flask(__name__)

   @app.route('/users/<int:id>', methods=['GET', 'PUT', 'DELETE'])
   def manage_user(id):
       if request.iss.onethod == 'GET':
           user = get_user_by_id(id)  # تابع فرضی برای دریافت کاربر
           return jsonify(user)
       elif request.iss.onethod == 'PUT':
           data = request.get_json()
           update_user(id, data)  # تابع فرضی برای به‌روزرسانی کاربر
           return jsonify({'message': 'User updated successfully'})
       elif request.iss.onethod == 'DELETE':
           delete_user(id)  # تابع فرضی برای حذف کاربر
           return jsonify({'message': 'User deleted successfully'})

   def get_user_by_id(user_id):
       # یک تابع فرضی برای دریافت کاربر از دیتابیس
       pass

   def update_user(user_id, data):
       # یک تابع فرضی برای به‌روزرسانی اطلاعات کاربر در دیتابیس
       pass

   def delete_user(user_id):
       # یک تابع فرضی برای حذف کاربر از دیتابیس
       pass

   if __name__ == '__main__':
       app.run(debug=True)
   

   @app.route('/add_user', methods=['POST'])
   def add_user():
       data = request.get_json()
       new_user = {"name": data['name'], "age": data['age']}
       add_user_to_db(new_user)  # تابع فرضی برای اضافه کردن کاربر به دیتابیس
       return jsonify(new_user), 201

   def add_user_to_db(user):
       # یک تابع فرضی برای اضافه کردن کاربر به دیتابیس
       pass
   

   from functools import wraps
   import jwt
   from flask import Flask, request, jsonify

   app = Flask(__name__)
   app.config['SECRET_KEY'] = 'your_secret_key'

   def token_required(f):
       @wraps(f)
       def decorated(*args, **kwargs):
           token = request.headers.get('x-access-token')
           if not token:
               return jsonify({'message': 'Token is missing!'}), 403
           try:
               data = jwt.decode(token, app.config['SECRET_KEY'], algorithms=["HS256"])
               current_user = get_user_by_id(data['id'])  # تابع فرضی برای دریافت کاربر
           except:
               return jsonify({'message': 'Token is invalid!'}), 403
           return f(current_user, *args, **kwargs)
       return decorated

   @app.route('/protected', methods=['GET'])
   @token_required
   def protected_route(current_user):
       return jsonify({'message': 'This is only available for authenticated users', 'user': current_user})

   if __name__ == '__main__':
       app.run(debug=True)
   

pip install SQLAlchemy

from sqlalchemy import create_engine, Column, Integer, String, Sequence
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# ایجاد یک Base برای تعریف مدل‌ها
Base = declarative_base()

# تعریف مدل کاربر
class User(Base):
    __tablename__ = 'users'
    id = Column(Integer, Sequence('user_id_seq'), primary_key=True)
    name = Column(String(50))
    age = Column(Integer)

# تنظیمات دیتابیس و ایجاد اتصال
engine = create_engine('sqlite:///users.db')
Base.metadata.create_all(engine)

# ایجاد جلسه برای تعامل با دیتابیس
Session = sessionmaker(bind=engine)
session = Session()

   new_user = User(name='Ali', age=25)
   session.add(new_user)
   session.commit()
   

   users = session.query(User).all()
   for user in users:
       print(user.name, user.age)
   

   user = session.query(User).filter_by(name='Ali').first()
   user.age = 26
   session.commit()
   

   user = session.query(User).filter_by(name='Ali').first()
   session.delete(user)
   session.commit()
   

from sqlalchemy import ForeignKey
from sqlalchemy.orm import relationship

class Post(Base):
    __tablename__ = 'posts'
    id = Column(Integer, Sequence('post_id_seq'), primary_key=True)
    title = Column(String(100))
    content = Column(String(500))
    user_id = Column(Integer, ForeignKey('users.id'))
    user = relationship('User', back_populates='posts')

User.posts = relationship('Post', order_by=Post.id, back_populates='user')

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

git init

git add .
git commit -m "Initial commit"

git branch new-feature
git checkout new-feature

git checkout main
git merge new-feature