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

pip install pytest

# calculator.py
def add(a, b):
    return a + b

# test_calculator.py
from calculator import add

def test_add():
    assert add(1, 2) == 3
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

pytest

      heroku create my-app
      

      git push heroku main
      

      heroku config:set DATABASE_URL=your_database_url
      

from cryptography.fernet import Fernet

# تولید کلید رمزنگاری
key = Fernet.generate_key()
cipher = Fernet(key)

# رمزنگاری داده‌ها
text = "Hello, World!"
encrypted_text = cipher.encrypt(text.encode())

# رمزگشایی داده‌ها
decrypted_text = cipher.decrypt(encrypted_text).decode()
print(decrypted_text)

import jwt
import datetime

# تولید توکن
def generate_token(user_id):
    payload = {
        'user_id': user_id,
        'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=1)
    }
    token = jwt.encode(payload, 'secret_key', algorithm='HS256')
    return token

# اعتبارسنجی توکن
def verify_token(token):
    try:
        payload = jwt.decode(token, 'secret_key', algorithms=['HS256'])
        return payload['user_id']
    except jwt.ExpiredSignatureError:
        return None