Адресная книга [Python etc]

;; обобщенная ф-ция чтения-записи в файл
(defun file-io-op (filename mode &optional data)
    (with-open-file
        (stream filename :direction mode :if-exists :supersede)
            (if (eq mode :output)
                (mapc #'(lambda (dp) (print dp stream)) data)
                (loop when (read stream nil) collect it
                    else do (loop-finish)))))

;; ф-ция загрузки книги из файла
(defun book-load (filename)
    (file-io-op filename :input))

;; ф-ция сохранения книги в файл
(defun book-save (book filename)
    (file-io-op filename :output book))

;; обобщенная ф-ция поиска данных
(defun book-find (subseq storage &key storage-type)
    (if (eq storage-type :file)
        (setf storage (file-io-op storage :input)))
    (mapcan
        #'(lambda (sl)
            (if (search (coerce subseq 'list)
                    (apply 'append
                        (mapcar #'(lambda (el) (coerce el 'list)) sl)))
                (list sl) nil))
        storage))

#!/usr/bin/env python
#-*-coding:cp1251-*-
import csv
import os

class View:
    def OutAddress(self, nick, fields):
        print nick, fields
   
    def OutNames(self, names):
        for name in names: print name
   
    def OutMessage(self, mess):
        print mess
           
    def GetAddress(self):
        phone = raw_input("Input a Phone: ")
        email = raw_input("Input an Email: ")
        return [phone, email]
   
    def GetCommand(self):
        return raw_input("Input command: ")
       
class Contr:
   
    def __init__(self, view, book):
        self.book = book
        self.view = view
        self.commands = {"quit": self.OnQuit, "q": self.OnQuit,
            "names": self.OnNames, "find": self.OnFind, "f": self.OnFind,
            "add": self.OnAdd, "del": self.OnDelete, "edit": self.OnEdit,
            "help": self.OnHelp}
           
    def Analysis(self, command):
        if len(command):
            parts = command.split(" ")
            command = parts[0].strip()
            if self.commands.has_key(command):
                return self.commands[command](parts[1:])          
            else:
                self.view.OutMessage("Use help for get info about commands")
   
    def OnHelp(self, parts):
        """ Help for help """
        if len(parts):
            if self.commands.has_key(parts[0]):
                self.view.OutMessage(self.commands[parts[0]].__doc__)
            else:
                self.view.OutMessage("Not found: " + parts[0])
        else: self.view.OutNames(sorted(self.commands.keys()))
   
    def OnFind(self, parts):
        """ Help for find """
        if not len(parts): return
   
        if self.book.has_key(parts[0]):
            self.view.OutAddress(parts[0], self.book[parts[0]])
        else:
            nicks = self.book.keys()
            notfound = True
            for s in nicks:
                name = str(s)
                if name.find(parts[0]) == 0:
                    self.view.OutAddress(name, self.book[name])
                    notfound = False
            if notfound: self.view.OutMessage(parts[0] + " not found")
       
    def OnAdd(self, parts):
        """ Help for add """
        nick = parts[0]
        self.book[nick] = self.view.GetAddress()
       
    def OnDelete(self, parts):
        """ Help for del """
        nick = parts[0]
        if self.book.has_key(nick):
            self.book.pop(nick)
            self.view.OutMessage(nick + " deleted")
        else: self.view.OutMessage("nick not found!")
       
    def OnEdit(self, parts):
        """ Help for edit """
        nick = parts[0]
        if self.book.has_key(nick):
            addr = self.view.GetAddress()        
            if(len(addr[0])):
                self.book[nick][0] = addr[0]
            if(len(addr[1])):
                self.book[nick][1] = addr[1]
        else: self.view.OutMessage("nick not found!")
       
    def OnNames(self, parts):
        """ Help for ... """
        self.view.OutNames(self.book.keys())
   
    def OnQuit(self, parts):
        """ Help for quit """
        return True
   
class Base:
    nick, phone, email = 0, 1, 2

    def __init__(self, fileName):
        self.baseName = fileName
        self.book = {}
       
    def Load(self):
        if os.path.exists(os.getcwd() + '\\' + self.baseName):
            csvReader = csv.reader(open( self.baseName, "r" ), delimiter = ';')        
            for row in csvReader:
                try: self.book[row[self.nick]] = [row[self.phone], row[self.email]]
                except:  pass        
   
    def Save(self):
        csvWriter = csv.writer(open(self.baseName, "w" ), delimiter = ';')
        for i in self.book:
            csvWriter.writerow( + self.book)
       
class Dispatcher:
   
    def __init__(self):
        self.view = View()
        self.base = Base("base.csv")
        self.contr = Contr(self.view, self.base.book)
       
    def Start(self):
        self.view.OutMessage("Hi!")
        self.base.Load()
   
    def Cycle(self):
        while True:
            if self.contr.Analysis(self.view.GetCommand()): break
        self.base.Save()
        self.view.OutMessage("Bye!")

if __name__ == "__main__":
    disp = Dispatcher()
   
    disp.Start()
    disp.Cycle()

#!/usr/bin/env python
import csv
import os

class Address: # module equivalent
    phone = 0
    email = 1
    fields = ("a Phone", "an Email")
    names = {"phone": phone, "email": email}

class View: # module equivalent
    def OutAddress(nick, fields):
        print nick, " => ", '; '.join([n + ": " + fields[Address.names[n]] for n in Address.names])
    OutAddress = staticmethod(OutAddress)
   
    def OutNames(names):
        for name in names: print name
    OutNames = staticmethod(OutNames)
   
    def OutMessage(mess):
        print mess
    OutMessage = staticmethod(OutMessage)
           
    def GetAddress():
        return [raw_input("Input " + p + ": ") for p in Address.fields]
    GetAddress = staticmethod(GetAddress)
   
    def GetCommand():
        return raw_input("Input command: ")
    GetCommand = staticmethod(GetCommand)

class Base:  # module equivalent

    baseName = "base.csv"
   
    def Load(book):
        nick = 0
        firstField = nick + 1
        lastField = firstField + len(Address.fields)
       
        if os.path.exists(os.getcwd() + '\\' + Base.baseName):
            csvReader = csv.reader(open( Base.baseName, "r" ), delimiter = ';')        
            for row in csvReader:
                try: book[row[nick]] = row[firstField : lastField]
                except:  pass        
    Load = staticmethod(Load)
   
    def Save(book):
        csvWriter = csv.writer(open(Base.baseName, "w" ), delimiter = ';')
        for i in book:
            csvWriter.writerow( + book)
    Save = staticmethod(Save)
       
class Contr:
   
    def __init__(self):
        self.book = {}
        Base.Load(self.book)
        self.commands = {"quit": self.OnQuit, "q": self.OnQuit,
            "names": self.OnNames, "find": self.OnFind, "f": self.OnFind,
            "add": self.OnAdd, "del": self.OnDelete, "edit": self.OnEdit,
            "help": self.OnHelp}
           
    def Analysis(self, command):
        if len(command):
            parts = command.split(" ")
            command = parts[0].strip()
            if self.commands.has_key(command):
                return self.commands[command](parts[1:])          
            else:
                View.OutMessage("Use help for get info about commands")
   
    def OnHelp(self, parts):
        """ Help for help """
        if len(parts):            
            if self.commands.has_key(parts[0]):
                View.OutMessage(self.commands[parts[0]].__doc__)
            else:
                View.OutMessage("Not found: " + parts[0])
        else: View.OutNames(sorted(self.commands.keys()))
   
    def OnFind(self, parts):
        """ Help for find """
        if not len(parts): return
   
        def FindNick(nick):
            if self.book.has_key(nick):
                View.OutAddress(nick, self.book[nick])
            else:
                nicks = self.book.keys()
                notfound = True
                for s in nicks:
                    name = str(s)
                    if name.find(nick) == 0:
                        View.OutAddress(name, self.book[name])
                        notfound = False
                if notfound: View.OutMessage(nick + " not found")
               
        def FindField(field, numb):
            notfound = True
            for addr in self.book:
                fieldStr = str(self.book[addr][numb])
                if fieldStr.find(field) == 0:
                    View.OutAddress(addr, self.book[addr])
                    notfound = False
            if notfound: View.OutMessage(field + " not found")
       
        if len(parts) == 1: FindNick(nick = parts[0])
        elif len(parts) == 2:
            name = parts[0]
            if Address.names.has_key(name):  FindField(parts[1], Address.names[name])
            else: View.OutMessage("You have used invalid key: ", name)
       
    def OnAdd(self, parts):
        """ Help for add """
        nick = parts[0]
        self.book[nick] = View.GetAddress()
        Base.Save(self.book)
       
    def OnDelete(self, parts):
        """ Help for del """
        nick = parts[0]
        if self.book.has_key(nick):
            self.book.pop(nick)
            Base.Save(self.book)            
            View.OutMessage(nick + " deleted")
        else: View.OutMessage("nick not found!")
       
    def OnEdit(self, parts):
        """ Help for edit """
        nick = parts[0]
        if self.book.has_key(nick):
            addr = View.GetAddress()        
            for i in xrange(len(addr)):
                if(len(addr)): self.book[nick] = addr
            Base.Save(self.book)            
        else: View.OutMessage("nick not found!")
       
    def OnNames(self, parts):
        """ Help for ... """
        View.OutNames(self.book.keys())
   
    def OnQuit(self, parts):
        """ Help for quit """
        return True
   
def Cycle():
    View.OutMessage("Hi!")
    contr = Contr()
    while True:
        if contr.Analysis(View.GetCommand()): break
    View.OutMessage("Bye!")

if __name__ == "__main__":
    Cycle()

(defpackage :address-book
  (:use :common-lisp :iterate))

(in-package :address-book)

;; обобщенная ф-ция чтения-записи в файл
(defun file-io-op (filename mode &optional data)
  (with-open-file
    (stream filename :direction mode :if-exists :supersede)
    (if (eq mode :output)
      (print data stream)
      (read stream nil))))

;; загрузка базы из файла
(defvar *address-book* (file-io-op "input" :input))
(defvar *basis* (cadr (assoc 'basis *address-book*)))

;; функция помощи нуждающимся
(defun userfunc-help (&optional command)
  (format t
    (or (case command
          ((help) ">> prints command's description~%>> e.g: help find~%~%")
          ((find) ">> find records by fields and its values~%~%")
          ((nil) ">> command list:~%>- help~%>- find~%~%>? for extra info about command~%>? type help %cmdname%, for e.g:~%>? help find~%~%"))
        ">> invalid argument!~%~%")))

;; макрос высшего порядка
(defmacro adbook-high-order (names conditions code)
  (let ((target-list (cadr (assoc 'data *address-book*))))
    `(iter (for lst* :on ',target-list)
        ,@(mapcar #'(lambda (name)
                     `(for ,name := (nth ,(position name *basis*) (car lst*))))
                  (eval names))
        (if ,(eval conditions) ,(eval code)))))

(defun userfunc-dump ()
  (print *address-book*))

;; поиск
(defun userfunc-find (&rest request)
  (let* ((lst (divide-by-tokens '(where) (if (equal (car request) 'record) (append *basis* (cdr request)) request)))
         (names (delete 'and (car lst)))
         (conditions (reduce 'infix-prefix `((and or) (equal ~) ,(nsubst 'equal '= (cadr lst))) :from-end t))
         (code `(collect (list ,@names)))
         (result (eval `(adbook-high-order ',names ',conditions ',code))))
    (iter (for r :in result)
          (iter (for i :in names)
                (for c :in r)
                (format t ">> ~a: ~a~%" i c))
          (finally (format t "~%")))))

;; добавление
(defun userfunc-add-record (&rest request)
  (let* ((lst (reduce 'delete `(and with = ,request) :from-end t))
        (result (iter (for field :in *basis*)
                      (collect (car (iter (for value :on lst :by 'cddr)
                                          (if (equal field (car value))
                                              (collect (cadr value)))))))))
    (if (notevery #'null result) (push result (cadadr *address-book*)))))

;; удаление
(defun userfunc-delete-record (&rest request)
  (let* ((lst (delete 'with request))
         (names (intersection lst *basis*))
         (conditions (reduce 'infix-prefix `((and or) (equal ~) ,(nsubst 'equal '= lst)) :from-end t))
         (code '(progn (format t ">> deleting record ~s~%" (car lst*)) (rplaca lst* (cadr lst*)) (rplacd lst* (cddr lst*)))))
    (eval `(adbook-high-order ',names ',conditions ',code))))

;; функция сопоставления со строчным образцом
(defun ~ (var-a var-b)
  (if (not (stringp var-b))
      (setf var-b (format nil "~a" var-b)))
  (if (equal (elt var-b (1- (length var-b))) #\*)
      (if (= (or (search (string-right-trim "*" var-b) var-a) -1) 0) t nil)
      (if (equal (elt var-b 0) #\*)
          (if (> (or (search (string-left-trim "*" var-b) var-a) -1) 0) t nil)
          (if (search var-b var-a) t nil))))

;; ф-ция перевода инфиксной записи в лисповаримую префиксную скобочную
(defun infix-prefix (operator-list target-list)
  (let* ((lst* (copy-list target-list))
         (result
           (iter (for i := lst*) (until (null lst*))
                  (if (member (cadr i) operator-list)
                     (progn (collect (cons (cadr i)
                                             (mapcar #'(lambda (k)
                                                        (if (listp k) (infix-prefix operator-list k) k))
                                                      (list (car i) (caddr i)))))
                             (setf lst* (cdddr lst*)))
                     (progn (collect (car i)) (setf lst* (cdr lst*)))))))
    (if (listp (car result)) (car result) result)))

;; ф-ция разбиения списка на подсписки токенами
(defun divide-by-tokens (token-list target-list)
  (iter (for i :in target-list)
        (if (member i token-list)
            (progn (collect temp :into result)
                    (setf temp '()))
            (collect i :into temp))
        (finally (return (nconc result (list temp))))))

;; парсит строку в лисповскую форму,
;; голова цела, хвост - заквочен
(defun adbook-parse-form (text-form)
  (let ((form (read (make-string-input-stream text-form))))
    (let ((tild* (if (member '~ form) (nthcdr (1+ (position '~ form)) form))))
      (if tild* (rplaca tild* (format nil "~a" (car tild*)))))
    (cons (car form) (mapcar #'(lambda (s) `',s) (cdr form)))))

;; приветствие и приглашение
(format t "| Address Book Operating Terminal |~% ...(type help to get cmdlist)... ~%~%address-book > ")

;; mainloop
(iter (for query := (string-right-trim '(#\Return) (read-line)))
      (until (string= "exit" query))
       (let ((form (adbook-parse-form (concatenate 'string "(userfunc-" query ")"))))
         (if (fboundp (car form))
            (eval form)
             (format t ">> invalid command!~%~%")))
      (princ "address-book > ")
      (force-output t))

using System;
using System.Collections.Generic;
using System.Console; // можно раскрывать статические члены класса :)
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml.Serialization;

using Nemerle;
using Nemerle.Assertions;
using Nemerle.Utility;

[Record] // макрос создаст конструктор, инициализирующий поля
[XmlType("Address")]
[Serializable]
public sealed class AddressEntry {

    public this() {  // требуется для работы сериализатора
    }
   
    [Accessor(flags = WantSetter)] // создает свойство с геттером и сэтером
    private mutable nick : string = string.Empty;
   
    [Accessor(flags = WantSetter)]
    private mutable email : string = string.Empty;
   
    [Accessor(flags = WantSetter)]
    private mutable phone : string = string.Empty;
   
    public override ToString() : string {
        $"$nick, $email, $phone"
    }
}

[XmlRoot] // корневой элемент XML файла
[XmlType("AddressBook")]
[Serializable]
public sealed class AddressEntryCollection : List[AddressEntry] {
}

// аналог перечисления enum
public enum SearchCriteria {
    | Nick
    | Email
    | Phone
}

public sealed class AddressBook : IDisposable {

    private static serializer : XmlSerializer = XmlSerializer(typeof(AddressEntryCollection));

    public this(file_name : string = "AddressBook.xml")  // можно использовать значения параметров по-умолчанию
        requires !string.IsNullOrEmpty(file_name)      // проверка параметра на корректность
            otherwise throw ArgumentException("Parameter 'file_name' must have non-emtpy value.")
    {
        this.file_name = file_name;
        this.data = if(File.Exists(file_name)) {
                using(stream = FileStream(file_name, FileMode.Open, FileAccess.Read))
                    serializer.Deserialize(stream) :> AddressEntryCollection
            } else
                AddressEntryCollection()
    }
   
    [Accessor]
    private file_name : string;
   
    private data : AddressEntryCollection;
   
    public Find(str : string, criteria : SearchCriteria) : list[AddressEntry] {
        def condition = match(criteria) {
            | Nick => fun(rec) { rec.Nick.IndexOf(str) >= 0 }
            | Email => fun(rec) { rec.Email.IndexOf(str) >= 0 }
            | Phone => fun(rec) { rec.Phone.IndexOf(str) >= 0 }
        }
       
        def searcher(seq) {
            if (seq.MoveNext())
                if (condition(seq.Current))
                    seq.Current :: searcher(seq)
                else searcher(seq)
            else []
        }
       
        using(seq = data.GetEnumerator()) {
            searcher(seq)
        }
    }
   
    public Add(rec : AddressEntry) : void {
        unless(data.Contains(rec))
            data.Add(rec)
    }
   
    public Remove(rec : AddressEntry) : void {
        _ = data.Remove(rec)
    }
   
    protected override Finalize() : void { // "деструктор" в терминах C#
        Dispose(false);
    }
   
    private Dispose(disposing : bool) : void {
        ignore(disposing); // чтобы компилятор не ругался на неиспользуемый параметр
       
        using(stream = FileStream(file_name, FileMode.Create, FileAccess.Write))
            serializer.Serialize(stream, data)
    }
   
    private mutable disposed : bool = false;
   
    public Dispose() : void {
        unless(disposed) {
            Dispose(true);
            GC.SuppressFinalize(this);  // отключаем "деструктор"
            disposed = true;
        }
    }
}

module Program {

    Main() : void {
        WriteLine("Welcome to address book keeper!");
       
        using(ab = AddressBook()) {
            WriteLine("Address book now loaded.");    
           
            mutable quit = false;
            while(!quit) {
                def input = ReadLine();
                when(input != string.Empty)
                    match(ParseInput(input)) {
                        | "q" :: [] | "quit" :: [] | "exit" :: [] => quit = true;
                        | "f" :: tail | "find" :: tail => DoFind(ab,  tail);
                        | "a" :: tail | "add" :: tail => DoAdd(ab, tail);
                        | "e" :: tail | "edit" :: tail => DoEdit(ab, tail);
                        | "d" :: tail | "delete" :: tail => DoDelete(ab, tail);
                        | _ => WriteLine("Input not recognized :(");
                    }
            }
           
            WriteLine("Saving changes...");
        }
       
        WriteLine("Bye!");
    }
   
    private pattern : Regex = Regex(<#(\".*?\")|(=)|((\w|\.|@|_|-)+)#>, RegexOptions.Compiled);
   
    ParseInput(str : string) : list[string] {
        def list_builder(seq) {
            if(seq.MoveNext()) {
                def m = seq.Current :> Match;
                if(m.Success)
                    m.Value :: list_builder(seq)
                else list_builder(seq)
             } else []
        }
        list_builder(pattern.Matches(str).GetEnumerator())
    }
   
   
    DoFind(ab : AddressBook, input : list[string]) : void {
        def result = match(input) {
            | "n" :: nick :: []
            | "nick" :: nick :: [] =>
                ab.Find(nick, SearchCriteria.Nick)
            | "e" :: email :: []
            | "email" :: email :: [] =>
                ab.Find(email, SearchCriteria.Email)
            | "p" :: phone :: []    
            | "phone" :: phone :: [] => ab.Find(phone, SearchCriteria.Phone)
            | _ => WriteLine("Input for searching not recognized :(");
                   []
        }
        match(result) {
            | [] => WriteLine("No records found.");
            | _ =>    WriteLine($"$(result.Length) record(s) found:");
                result.Iter(WriteLine);
        }
    }
   
    SetEntryField(entry : AddressEntry, field : string, value : string) : bool {
        match(field) {
            | "n" | "nick" =>  entry.Nick = value; true
            | "e" | "mail" | "email" => entry.Email = value; true
            | "p" | "phone" | "mobile" => entry.Phone = value; true
            | _ => false
        }
    }
   
    ParseEntryFields(entry : AddressEntry, input : list[string]) : bool {
        match(input) {  
            | [] => true
            | field :: "=" :: value :: tail
            | field :: value :: tail =>
                ParseEntryFields(entry, tail) && SetEntryField(entry, field, value)
            | _ => false
        }
    }
   
    DoAdd(ab : AddressBook, input : list[string]) : void {
        def entry = AddressEntry();
       
        if(ParseEntryFields(entry, input)) {
            ab.Add(entry);
            WriteLine($"New record added: $entry");
        } else
            WriteLine("Invalid input :(");
    }
   
    DoEdit(ab : AddressBook, input : list[string]) : void {
        match(input) {
            | nick :: tail =>
                match(ab.Find(nick, SearchCriteria.Nick)) {
                    | entry :: _ =>
                        if(ParseEntryFields(entry, tail))
                            WriteLine($"Record changed to: $entry.")
                        else
                            WriteLine($"Some input not recognized, new record: $entry.")
                    | _ => WriteLine($"No records for '$nick' found.");
                }
            | _ => WriteLine("Invalid input :(");
        }
    }
   
    DoDelete(ab : AddressBook, input : list[string]) : void {
        match(input) {
            | nick :: [] =>
                match(ab.Find(nick, SearchCriteria.Nick)) {
                    | entry :: _ => {
                            WriteLine($"Deleting first found entry $entry");
                            ab.Remove(entry);
                        }                        
                    | _ => WriteLine($"No records for '$nick' found.");
                }
            | _ => WriteLine("Invalid input :(");
        }
    }
   

}

((basis (nick email phone))
(data
  (("Ander Skirnir" "some-email@mail.ru" 991-19-09)
  ("Evil Invader" "abigor@hellfire.pwnz" 1010011010))))