def solution(s):
    words = ['zero', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine']
    for word in words:
        if word in s:
            s = s.replace(word, str(words.index(word)))
            #문자 : 숫자를 딕셔너리로 짝지으려고 했는데 문자열이 의미하는 숫자가 인덱스값과 같아서 그냥 인덱스값을 넣었다.
    return int(s)

num_dic = {"zero":"0", "one":"1", "two":"2", "three":"3", "four":"4", "five":"5", "six":"6", "seven":"7", "eight":"8", "nine":"9"}

def solution(s):
    answer = s
    for key, value in num_dic.items():
        answer = answer.replace(key, value)
    return int(answer)

class Transformer(object):
    #10진수로 변환할 경우 숫자들의 리스트 
    #This Transformaer class takes list of numbers that are being used in certain digit(진법) and hand it over to initializing method.
    decimal_digits = "0123456789"
    #For example, decimal digit takes 0 to 9, Binary digit takes 0 and 1.
    #digits는 n진수의 숫자리스트
    def __init__(self, digits):
        self.digits = digits

    #바꾸고자하는 십진수 수가 i에 들어가고 i값과 십진수 숫자리스트, 바꾸고자하는 진수의 숫자리스트를 반환한다.
    #This question is about converting digit from and to decimal digits so we make two methods. 
    def from_decimal(self, i):
        return self._convert(i, self.decimal_digits, self.digits)
    
    #바꾸고자하는 n진수 수가 s에 들어가고 s값과 바꾸고자하는 진수의 숫자리스트, 십진수 숫자리스트를 반환한다.
    #Order of decimal digits and digits matters since we are going to use convert method for both actions.
    def to_decimal(self, s):
        return int(self._convert(s, self.digits, self.decimal_digits))
    
    #convert method takes number that we'd likt to change, which digit we are going to change from and to.
    def _convert(self, number, fromdigits, todigits):
        # 입력받은 숫자, 바꾸기 전 진수의 숫자리스트, 바꾼 뒤의 진수의 숫자리스트를 받는다. 예(555,BASE10,BASE2)
        # 숫자리스트의 길이에 따라 어떤 진수로 바뀔지 정해진다.
        # length of these parameters decides which digits we're going to convert.
        fromdigits_len, todigits_len = len(fromdigits), len(todigits)
        # 해당 진수의 숫자리스트의 길이를 저장한다. 예(BASE10은 10진수, '0123456789' 이므로 10개)
        number = str(number)
        number_len = len(number)
        # 입력받은 숫자의 길이도 저장한다

        tmp_dec=0
        # 숫자의 갯수만큼 지수를 곱해서 더하여 십진수로 변환한 값을 저장한다. 
        # 예: 100(2진수)이면 (2의2승 * 1) + (2의1승 * 0) + (2의0승 * 0)
        # Here we change all number into decimal digits.
        for idx, n in enumerate(number):
            # 예를 들어 십진수 1234이면 idx는 0,1,2,3 n은 1,2,3,4
            print('idx :', idx)
            print('n : ', n)
            # By using base, exponent and digit of the number.
            tmp = fromdigits_len ** (number_len-idx-1) * fromdigits.index(n)
            #fromdigits_len(밑)이 십진수일 때 10이고 number_len-idx-1(지수)이 1234일때 각 3210으로 10의 지수
            #fromdigits.index(n)은 1,2,3,4로 '012..89'숫자리스트에서 n번째 숫자
            print('number_len-idx-1 :', number_len-idx-1)
            print('fromdigits.index(n):', fromdigits.index(n))
            #tmp에 각 자릿수를 십진수로 계산한 값을 더한다
            tmp_dec += tmp
        
        result=''
        while tmp_dec > 0:
            # 몫과 나머지를 구하는 파이썬의 내장함수 divmod사용
            # And from here we change it back to N base by dividing and saving remainders.
            tmp_dec, mod = divmod(tmp_dec, todigits_len)
            # 10진수로된 tmp_dec를 바꾸자하는 진수의 숫자리스트길이로 나누어서
            result += str(todigits[mod])
            # 나온 나머지들을 반대로 정렬 
        return result[::-1]

BASE2 = Transformer("01")
BASE10 = Transformer("0123456789")
BASE16 = Transformer("0123456789ABCDEF")
BASE20 = Transformer("0123456789abcdefghij")
BASE62 = Transformer("ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz")

print(BASE20.from_decimal('1234'))
# print(BASE2.to_decimal('1000101011'))

from math import log

    #10진수에서 원하는 진수로 바꾸기(바꿀 숫자, 바꿀 숫자의 진수)
def convertFromBase10(num, base):
    #변경할 숫자의 리스트
    numToChar = {i : "0123456789ABCDEF"[i] for i in range(16)}
    #가장 큰 지수를 power에 저장 
    power = int(log(num, base))
    converted = ""
    #power숫자부터 0까지 거꾸로 돌리기
    for pow in range(power, -1, -1):
        # 진수의 가장 큰 지수(예 7의3승)로 주어진 숫자를 나누어서 몫을 converted에 더하고  
        converted += numToChar[num // (base**pow)]
        # 나머지를 다시 숫자의 자리에 넣음
        num %= base**pow
    return converted

print(convertFromBase10(429,7))
#1152

BASE2 = "01"
BASE10 = "0123456789"
BASE16 = "0123456789ABCDEF"
BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz"

def baseconvert(number,fromdigits,todigits):
    #converts a "number" between two bases of arbitrary digits

    # The input number is assumed to be a string of digits from the
    # fromdigits string (which is in order of smallest to largest
    # digit). The return value is a string of elements from todigits
    # (ordered in the same way). The input and output bases are
    # determined from the lengths of the digit strings. Negative 
    # signs are passed through.

    # decimal to binary
    # >>> baseconvert(555,BASE10,BASE2)
    # '1000101011'

    # binary to decimal
    # >>> baseconvert('1000101011',BASE2,BASE10)
    # '555'

    # integer interpreted as binary and converted to decimal (!)
    # >>> baseconvert(1000101011,BASE2,BASE10)
    # '555'

    # base10 to base4
    # >>> baseconvert(99,BASE10,"0123")
    # '1203'

    # base4 to base5 (with alphabetic digits)
    # >>> baseconvert(1203,"0123","abcde")
    # 'dee'

    # base5, alpha digits back to base 10
    # >>> baseconvert('dee',"abcde",BASE10)
    # '99'

    # decimal to a base that uses A-Z0-9a-z for its digits
    # >>> baseconvert(257938572394L,BASE10,BASE62)
    # 'E78Lxik'

    # ..convert back
    # >>> baseconvert('E78Lxik',BASE62,BASE10)
    # '257938572394'

    # binary to a base with words for digits (the function cannot convert this back)
    # >>> baseconvert('1101',BASE2,('Zero','One'))
    # 'OneOneZeroOne'

    # make an integer out of the number
    x=long(0)
    for digit in str(number):
       x = x*len(fromdigits) + fromdigits.index(digit)
       
    # create the result in base 'len(todigits)'
    res=""
    while x>0:
        digit = x % len(todigits)
        res = todigits[digit] + res
        x /= len(todigits)
    return res

def nnconverter(number, fromdigits, todigits):
    fromdigits_len, todigits_len = len(fromdigits), len(todigits)
    number = str(number)
    number_len = len(number)

    tmp_dec=0
    for idx, n in enumerate(number):
        tmp = fromdigits_len ** (number_len-idx-1) * fromdigits.index(n)
        tmp_dec += tmp
    
    result=''
    while tmp_dec > 0:
        tmp_dec, mod = divmod(tmp_dec, todigits_len)
        result += str(todigits[mod])
    return result[::-1]

BASE2 = "01"
BASE10 = "0123456789"
BASE16 = "0123456789ABCDEF"
BASE20 = "0123456789abcdefghij"
BASE62 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz"

print(nnconverter('31e', BASE20, BASE2))

#현묵님이 작성하신 디비 업로더 파일
import urllib.request
import json
import django
import os

from django.db import transaction

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'cardoc.settings')
django.setup()

from tires.models import Tire

def DataUploader():
    
    trimid = ["5000", "9000", "11000", "15000"]
    
    for i in trimid:
        url = "https://dev.mycar.cardoc.co.kr/v1/trim/" + i

        response    = urllib.request.urlopen(url)
        json_str    = response.read().decode("utf-8")
        json_object = json.loads(json_str)
        data        = json_object
        frontTire   = data['spec']['driving']['frontTire']['value']
        rearTire    = data['spec']['driving']['rearTire']['value']

        Tire.objects.create(
            trimid          = int(i),
            f_section_width = int(frontTire.split('/')[0]),
            f_aspect_ratio  = int(frontTire.split('/')[1].split('R')[0]),
            f_rim_diameter  = int(frontTire.split('/')[1].split('R')[1]),
            r_section_width = int(rearTire.split('/')[0]),
            r_aspect_ratio  = int(rearTire.split('/')[1].split('R')[0]),
            r_rim_diameter  = int(rearTire.split('/')[1].split('R')[1]),
        )

DataUploader()

#vehicle > views.py
from datetime                        import datetime

from rest_framework                  import status, viewsets, response
from rest_framework.decorators       import action
from rest_framework.permissions      import IsAuthenticated, AllowAny

from vehicle.models                  import Deer, BoardingLog
from user.serializers                import UserSerializer
from vehicle.serializers             import DeerSerializer, BoardingLogSerializer

class VehicleViewSet(viewsets.GenericViewSet):
    quertset           = Deer.objects.all()
    serializer_class   = DeerSerializer
    permission_classes = [IsAuthenticated]
    lookup_field       = 'deer_name'

    #킥보드를 대여하는 로직, 파라미터를 받는 경우에 detail=True를 적용한다. 
    @action(detail=True, methods=['POST'])
    def rent(self, request, deer_name):
        #사용자가 킥보드를 대여중인 경우
        if BoardingLog.objects.filter(user_id = request.user.id, in_use=True).exists():
            return response.Response("One Deer Allowed", status=status.HTTP_400_BAD_REQUEST)
        #킥보드가 사용중인 경우
        if BoardingLog.objects.filter(deer__name = deer_name, in_use=True).exists():
            return response.Response("Already In Use", status=status.HTTP_400_BAD_REQUEST)

        BoardingLog.objects.create(
            user_id = request.user.id,
            deer = Deer.objects.get(name = deer_name),
            in_use = True,
            use_start_at = datetime.now()
        )
        return response.Response("Start Using Deer", status=status.HTTP_200_OK)

#research > views.py
#import 부분 생략

#method_decorator를 사용하면 함수가 아닌 Class에 스웨거를 넣을 수 있다.
@method_decorator(name='get', decorator=swagger_auto_schema(
    operation_id ="연구 데이터 상세 조회",
    operation_description ="연구 번호를 입력하세요\n\n" +
                            "예시 : C160008",
    responses    = {
        "201": "SUCCESS",
        "404": "NOT_FOUND",
        "400": "BAD_REQUEST",
    }
))
class ResearchRetrieveView(RetrieveAPIView):
    queryset            = ResearchInformation.objects.all()
    serializer_class    = ResearchInformationSerializer
    lookup_field        = 'number'

#스웨거상에서 함수가 아닌 클래스에 예시를 넣는 방법을 시간상 못 찾아서 설명 부분에 같이 넣었다. 
@method_decorator(name='get', decorator=swagger_auto_schema(
    operation_id ="연구 데이터 검색",
    operation_description = "전체 연구 데이터를 필터 및 검색합니다.\n\n"
                            "필터 : 과제명(name), 연구기간(range), 연구종류(code), 연구책임기관(institute), 임상시험단계(연구모형)(stage), 연구책임기관(institute), 임상시험단계(stage), 전체목표연구대상자수(target_number), 진료과(office), 최고 연구기간(min_target_number), 최대 연구기간(max_target_number)의 필터 및 개별 검색 가능\n\n" +
                            "전체 검색 : search 값에 검색하고 싶은 단어 입력" +
                            "(과제명, 과제번호, 연구기간, 연구종류, 연구책임기관, 임상시험단계(연구모형), 진료과 중 검색 가능)\n\n" +
                            "정렬 : 업데이트된 날짜 역순으로 기본 정렬, 기준으로 정렬하고 싶은 컬럼의 키값을 ordering에 입력하세요\n\n" +
                            "예시 : \n" +
                            "{\n"+
                                "id: 10,\n"+
                                "name: 제2형 당뇨병 임상연구네트워크 구축사업\n"+
                                "number: C140014\n"+
                                "period: 120개월\n"+
                                "range: 국내다기관\n"+
                                "code: 관찰연구\n"+
                                "institute: 경희대학교병원\n"+
                                "stage: 코호트\n"+
                                "target_number: 700\n"+
                                "office: Endocrinology\n"+
                                "created_at: 2021-11-16\n"+
                                "updated_at: 2021-11-16\n"+
                            "}",
    responses    = {
        "201": "SUCCESS",
        "404": "NOT_FOUND",
        "400": "BAD_REQUEST",
    }
))
#이렇게 drf내부의 서치뷰를 사용하면 아래컬럼을 모두 포함하는 검색을 구현할 수 있다. 
class SearchResearchView(ListAPIView):
    queryset            = ResearchInformation.objects.all()
    serializer_class    = ResearchInformationSerializer
    filter_backends     = [DjangoFilterBackend, OrderingFilter, SearchFilter]
    filterset_class     = ResearchFilter
    ordering            = ['-updated_at']
    search_fields       = ['name', 'number', 'range', 'code', 'institute', 'stage', 'office']

#research > tests.py
from rest_framework         import status
from rest_framework.test    import APITestCase

from research.models        import ResearchInformation

from django.core import serializers


class ResearchRetrieveTests(APITestCase):
    @classmethod
    def setUpTestData(cls):
        ResearchInformation.objects.create(
            name="조직구증식증 임상연구 네트워크 구축 및 운영(HLH)",
            number="C130010",
            period="3년",
            range="국내다기관",
            code="관찰연구",
            institute="서울아산병원",
            stage="코호트",
            target_number="120",
            office="Pediatrics",
            created_at="2021-11-16",
            updated_at="2021-11-16"
        )
        ResearchInformation.objects.create(
            name="대한민국 쇼그렌 증후군 코호트 구축",
            number="C130011",
            period="6년",
            range="국내다기관",
            code="관찰연구",
            institute="가톨릭대 서울성모병원",
            stage="코호트",
            target_number="500",
            office="Rheumatology",
            created_at="2021-11-16",
            updated_at="2021-11-16",
        )
        ResearchInformation.objects.create(
            name="Lymphoma Study for Auto",
            number="C100002",
            period="1년",
            range="단일기관",
            code="국내연구",
            institute="가톨릭대 서울성모병원",
            stage="Case-only",
            target_number="200",
            office="Hematology",
            created_at="2021-11-16",
            updated_at="2021-11-16"
        )

    #처음에는 검색 결과가 문자열로 그대로 일치하도록 작성하려고했는데 여의치 않아서 객체로 비교하도록 했다.
    def test_detail_view_success(self):
        response = self.client.get('/researches/C100002')
        
        expected_data_id = ResearchInformation.objects.get(number='C100002').id

        self.assertEqual(response.json()['id'], expected_data_id)
        self.assertEqual(response.status_code, status.HTTP_200_OK)
    
    def test_detail_view_fail(self):
        response = self.client.get(
            '/researches/C140111'
            )

        self.assertEqual(response.json(), {"detail" : "Not found."})
        self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND)

#users > model.py
from django.db                  import models
from django.contrib.auth.models import BaseUserManager, AbstractBaseUser


#BaseUserManager를 상속받아서 유저메니저 클래스가 유저를 생성하게된다
class UserManager(BaseUserManager):
    def create_user(self, email, name, password=None):
        if not email:
            raise ValueError('Users must have an email address')

        user = self.model(
            email = self.normalize_email(email),
            name  = name,
        )

        user.set_password(password)
        user.save(using=self._db)
        return user

#AbstractBaseUser에서 기본으로 만들어져있는 모델의 유저필드들을 받은 뒤 커스텀해서 사용한다
class User(AbstractBaseUser):
    email      = models.EmailField(max_length=255, unique=True)
    name       = models.CharField(max_length=20)
    is_admin   = models.BooleanField(default=False)
    username   = models.CharField(max_length=10, default='', null=True, blank=True)

    objects = UserManager()

    #유저네임대신 이메일로 로그인한다
    USERNAME_FIELD  = 'email'
    #은행업무이기 때문에 실명을 꼭 받도록했다.
    REQUIRED_FIELDS = ['name']

    def __str__(self):
        return self.email

    def has_perm(self, perm, obj=None):
        return True

    def has_module_perms(self, app_label):
        return True

    @property
    def is_staff(self):
        return self.is_admin
    
    class Meta:
        db_table = 'users'

#users > view.py
from rest_framework             import generics
from rest_framework.generics    import CreateAPIView
from rest_framework.permissions import AllowAny
from django.contrib.auth        import get_user_model

from .permissions               import IsOwner
from users.models               import User
from .serializers               import RegisterUserSerializer, UserSerializer


class RegisterUserView(CreateAPIView):
    permission_classes = [AllowAny]
    serializer_class   = RegisterUserSerializer

#유저정보를 조회하는 코드, RetrieveAPIView를 사용해서 코드를 쓰지 않아도 자동으로 1개 객체의 정보를 조회하는 기능이 구현된다.  
class UserDetailAPIView(generics.RetrieveAPIView):
    queryset           = get_user_model().objects.all()
    serializer_class   = UserSerializer
    permission_classes = [IsOwner]

company_name : {
    'ko': '라인',
    'en': 'Line',
    'ja': 'ライン'
}

if request.headers['X-Wanted-Language'] is False:
            language = 'ko'
        else :
            language = request.headers['X-Wanted-Language']

class CompanySearchAPIView(views.APIView):

    def get(self, request):
        search  = request.GET.get('query', None)
        results = []

        if search is None:
            return response.Response(results, status=status.HTTP_200_OK)

        language = request.headers.get('x-wanted-language', 'ko')

        #JSON구조에 따라 depth 안 쪽으로 들어가서 company_name : { ko : 여기를 검색 } 하도록 함    
        c = {f'company_name__{language}__icontains': search}

        companies = Company.objects.filter(**c)
        company_serializer = CompanySerializer(companies, many=True)

        results = [{
             "company_name" : company['company_name'][language]
        } for company in company_serializer.data]

        return response.Response(results, status=status.HTTP_200_OK)

class MusicianViewSet(viewsets.GenericViewSet):
    permission_classes = [AllowAny]

    #뮤지션 CRUD
    def create(self, request):
        name = request.data.get('name')
        if name is None:
            return Response({'error': 'name field is required.'},status=status.HTTP_400_BAD_REQUEST)
        musician = Musician(name=name).save()
        rtn = MusicianSerializer(musician).data
        return Response(rtn, status=status.HTTP_201_CREATED)

    def list(self, request):
        musicians = Musician.nodes.all()
        rtn = MusicianSerializer(musicians, many=True).data
        return Response(rtn, status=status.HTTP_200_OK)

    def retrieve(self, request, pk):
        musician = Musician.nodes.get_or_none(uuid=pk)
        if musician is None:
            return Response({'error': 'DoesNotExist'})
        rtn = MusicianSerializer(musician).data
        return Response(rtn, status=status.HTTP_200_OK)

    def destroy(self, request, pk):
        musician = Musician.nodes.get_or_none(uuid=pk)
        musician.delete()
        return Response(status=status.HTTP_200_OK)
    
    #특정 뮤지션의 곡들을 조회 
    @action(detail=True, methods=['GET'])
    def songs(self, request, pk):
        musician = Musician.nodes.get_or_none(uuid=pk)
        if musician is None:
            return Response({'error': 'DoesNotExist'})
        songs = musician.song.all()
        rtn = SongSerializer(songs, many=True).data
        return Response(rtn, status=status.HTTP_200_OK)

class CommentView(View):
    @login_decorator
    def get(self, request, post_id):
        parent_id = int(request.GET.get("parent_id","0"))
        #parent_id를 받아와서 저장한다. 없는 경우에는 0.

        if parent_id == 0:
            all_comments = Comment.objects.filter(post_id=post_id, parent_comment__isnull=True).select_related('user')
        #parent_id가 0인 경우(대댓글이 아닌 댓글)에는 parent_comment_id 컬럼이 null인 코멘트들(댓글)을 불러온다. 'parent_id' 라는 변수에 0이 입력되면 댓글을 조회
        
        else:
            all_comments = Comment.objects.filter(post_id=post_id, parent_comment_id=parent_id).select_related('user')
        #대댓글일 경우에는 parent_comment_id가 해당 id인 코멘트들(대댓글)을 불러온다. 'parent_id' 라는 변수에 *이 입력되면 *번 댓글의 대댓글을 조회

        limit = int(request.GET.get("limit","10"))
        offset = int(request.GET.get("offset","0"))
        offset=offset*limit
        
        comments  = all_comments[offset:offset+limit]
        #대댓글의 페이지네이션을 짤 때 어떤 순서로 댓글을 보여주어야할 지 고민했었는데 

        comment_list = [{   
                'comment_id' : comment.id,
                'user_id'    : comment.user_id,
                'email'      : comment.user.email,
                'content'    : comment.content,
                'created_at' : comment.created_at,
                'updated_at' : comment.updated_at,
                'parent_id'  : comment.parent_comment_id,
                } for comment in comments
            ]
        return JsonResponse({'comments':comment_list}, status=200)