Скринкаст о Test-Driven SharePoint Development

Записал скринкаст о том, как разрабатывал Sapphire REPL WebPart.

Октябрь 27, 2009. Метки: , , , , , , . Uncategorized. Оставить комментарий.

REPL WebPart для SharePoint

Intro

logoСегодня я расскажу о прототипе первого компонента под ярлычком Sapphire. Это REPL WebPart. Эта веб-часть предназначенная для производства оперативных изменений на серверной стороне SharePoint, так же для удаленного исполнения скриптов и тестирования некоторых кусков кода.

PreBody

Производство данной веб-части было инициированно в довольно таки частых потребностях исполнения серверного кода с достаточной оперативностью, в недоступности средств разработки под рукой.

Здесь есть небольшая презетнация, в которой я постарался отобразить принципы работы Repl WebPart:

Sapphire Environment Repl WebPart
View more documents from Vitaly Baum.

В добавок к слайдам расскажу о том, что веб-часть представляет собой классический хостинг Dynamic Languages Runtime языков, пока из которых доступен только Python.

Body

Далее хотелось поговорить о том, как же всё это у меня получилось, итак проект включает в себе несколько основных модулей:

  • Веб-часть и контролы представления
  • Хостинг языков

Далее о них поподробнее

Language Hosting

В связи с тем, что языков, которые я захочу реализовать в данном проекте является неограниченное множество, то конечно же мне необходима абстрактная фабрика для их создания, которая будет скрывать иерархию всех доступных языков и инкапсулировать их под интерфейсом:

  public interface ILanguagesFactory
  {
    ILanguage Create(string name);
  }

  public interface ILanguage
  {
    string Name { get; }

    object Execute(string input);

    void SetVar(string name, object value);
    
    object GetVar(string name);
  }

Отлично, далее к нашему проекту присоединяются сборки, необходимые для имплементации скриптовых языков:

Всё готово для того, чтобы реализовать Python, как среду для исполнения кода, отлично, приступим:

  public class PythonLanguage : ILanguage
  {
    private readonly ScriptScope _scope;
    
    public string Name
    {
      get { return «Python»; }
    }

    public PythonLanguage()
    {
      _scope = Python.CreateEngine().CreateScope();
    }

    public object Execute(string input)
    {
      ScriptSource source = _scope.Engine.CreateScriptSourceFromString(input);
      return source.Execute(_scope);
    }
  }

Далее немного усложним задачу, в связи с тем, что нам будет необходимо реализовать контекст для работы с SharePoint, выглядеть это должно примерно так:

    [Test]
    private void python_should_assume_sharepoint_variables()
    {
      SPWeb fakeWeb = Isolate.Fake.Instance<SPWeb>();
      Isolate.WhenCalled(() => fakeWeb.Title).WillReturn(«I’m fake web»);
      var python = _factory.Create(«Python»);
      python.SetVar(«__x__», «123″);
      python.SetVar(«__web__», fakeWeb);
      python.Execute(«__x__ = __web__.Title»);
      var x = (string)python.GetVar(«__x__»);
      Assert.AreEqual(x, «I’m fake web»);
    }

Для работы с объектами SharePoint в из IronPython, нам необходимо добавить несколько библиотек:

      _scope.Engine.Runtime.LoadAssembly(typeof(string).Assembly);
      _scope.Engine.Runtime.LoadAssembly(typeof(Uri).Assembly);
      _scope.Engine.Runtime.LoadAssembly(typeof(SPList).Assembly); 

Это будет основой нашей работы с динамическими языками

WebPart + WebControls

Создадим проект с помощью SPVisualDev, добавим в него feature, внутри которой создадим веб-часть Repl WebPart, всё остальные действия стандартные, однако есть небольшой нюанс, нам нужен будет объект, с помощью которого можно будет выводить строковые значения после исполнения. Я решил создать для этих целей объект с классическим названием Console, его реализация предельна проста:

  public class Console
  {
    private readonly StringBuilder _messageBuilder = new StringBuilder();

    public void Write(object message)
    {
      _messageBuilder.Append(message);
    }

    public void WriteLine(object message)
    {
      _messageBuilder.AppendLine(message.ToString());
    }

    public string Message
    {
      get
      {
        return _messageBuilder.ToString();
      }
    }
  }

Мы будем передавать его в среду исполнения языков, а после исполнения кода опрашивать его свойство Message и выводить его содержимое в нашу веб-часть.

EndBody

Все исходники проекта доступны на github: http://github.com/butaji/Sapphire

Так же предварительную версию Sapphire.Environment (решение поставляется в WSP) можно слить на CodePlex: http://sapphire.codeplex.com/Release/ProjectReleases.aspx?ReleaseId=34895

Октябрь 24, 2009. Метки: , , , , . .net, C#, DLR, Python, sharepoint, tdd. 1 комментарий.

Кратко о Patterns & Practices: SharePoint Guidance

Интро

clip_image001

В данной статье я хочу произвести обзор руководства под названием “SharePoint Guidance” от подразделения Microsoft patterns & practices. Данное руководство предназначено разработчикам/архитекторам SharePoint, в нём описаны основные принципы построения систем на данной платформе. Над руководством трудились выдающиеся представители разработки под SharePoint, а так же он упорно держится в списке самых активных проектов на CodePlex. Далее чуть подробнее.

Описание руководства

Руководство фактически состоит из нескольких аспектов:

  1. SharePoint Guidance Library – библиотека наиболее используемых и полезных функций, таких как управление конфигурацией, абстрагирование слоя данных, логирование событий и сервисная инфраструктура
  2. Документация, в которой подробно описаны все принципы построения приведенных примеров, а так же руководства по основным вопросам, возникающим в разработке на SharePoint.
  3. Contoso Partner Portal Reference Implementation – показательное приложение на MOSS некоей компании Contoso, являющее собой экстранет-портал, в приложении используются практики наиболее приближенные к промышленным решениям.
  4. Contoso Training Management Reference Implementation – простое приложение HR-отдела, демонстрирующее базовые принципы построения решений на WSS.
  5. QuickStarts – два небольших примера самых простых приложений на SharePoint, а так же доступа к данным

Помимо исходных кодов и юнит-тестов к ним, примерами так же являются установочные скрипты, билд-скрипты, что фактически является артифактами верно налаженного процесса производства ПО, что очень показательно и полезно с практической точки зрения.

image

Обзор руководства

1ая версия вышла в прошлом году (Dec2008), в настоящее время доступна 2ая версия данного руководства (Aug2009), о ней и будет идти речь.

  • Introduction – небольшое введение, а так же рекомендации к инструментам разработки: VSeWSS, U2U CAML Query Builder, CAML.NET, Typemock Isolator
  • Developing SharePoint Applications – основные сценарии разработки под платформу, а так же её ключевые возможности
  • Design and Development Guidelines – отображены ключевые моменты архитектуры SharePoint, а так же описаны подходы решения тех или иных задач разработки под платформу; описаны рекомендации к управлению жизненным циклом проектов
  • Application and Design Patterns – одна из наиболее интересных глав, в ней описаны как классические паттерны построения корпоративных приложений ложатся на решения под SharePoint
  • The SharePoint Guidance Library – описание библиотеки со всеми ключевыми возможностями и компонентами для разработки
  • Integrating Line-of-Business Systems – описание интеграции с существующими корпоративными системами
  • Considerations for Content-Driven Applications – здесь можно узнать о том, как правильно строить приложения, для хранения контента
  • Considerations for Enterprise-Scale Applications – рекомендации по созданию приложений масштаба предприятия
  • Considerations for Extranet Development – рекомендации по разработке и планированию экстранет-порталов
  • Partner Portal Reference Implementation – описание построения приложения-примера для MOSS
  • Training Management Reference Implementation– описание построения приложения-примера для WSS
  • QuickStarts – описание приложения для легкого старта работы с SharePoint

Критика

logo Данное руководство содержит в себе большое количество практичной полезной информации, однако в некоторых технических решениях моя точка зрения расходится с его создателями, в связи с чем мною был начат проект Sapphire: SharePoint Application Framework, который будет так же являться каркасом для построения решений на SharePoint, а так же включать примеры решений и необходимые в повседневной разработке компоненты.

Ресурсы по SharePoint Guidance

Скачать полную версию за август 2009 года можно здесь:

SharePoint Guidance так же представлен на CodePlex: http://www.codeplex.com/spg/ здесь можно задать интересующие вопросы и скачать все последние изменения.

Так же некоторые главы из SharePoint Guidance представлены в видеоряде на channel 9:

Ресурсы по SharePoint

TechNet располагает огромным количеством статей и книг по SharePoint, конечно в них не так много внимания уделено именно разработке, однако для формирования вижна платформы весьма полезно: http://technet.microsoft.com/en-us/library/cc262788.aspx

SharePoint Developer Center здесь можно найти практически всё, что нужно для разработки на SharePoint

Октябрь 19, 2009. Метки: , , . .net, Sapphire, patterns & practices, sharepoint. Оставить комментарий.

Habrahabr, Live Writer и Code Highlighting

Интро

Уже практически полгода я пользуюсь Windows Live Writer в качестве инструмента для написания веб-ориентированных статей. Это отличный инструмент, работающий с большим количеством blogengine’ов, и даже с SharePoint. Но разговор не об этом, в связи с тем, что я разработчик, мне частенько приходится вставлять листинг кода в написанные статьи, на это я и хочу обратить ваше внимание.

Пигменты

Многие представители Python-сообщества наверняка знакомы с дивным проектом под названием Pygments:

Ну так вот, товарищ Harry Pierson (@DevHawk) скомпилировал этот движок под IronPython и написал обертку-плагин для Windows Live Writer (качать здесь не торопиться). Отлично, однако то, что получается в результате его обработки не выделяется цветом на habrahabr, это связанно с некоторыми особенностями ресурса, однако поправимо.

Данными работами я и предлагаю заняться, для этого нам понадобятся:

После того, как мы скачали исходники, стоит разыскать скрипт под именем pygments_package\devhawk_formatter.py и немного его подкоректировать:

            # a style item is a tuple in the following form:
            # colors are readily specified in hex: ’RRGGBB’
            if style['color']:
                start += ‘<span style=»color:#%s«>’ % style['color']
                end = ‘</span>’ + end

заменить на

            # a style item is a tuple in the following form:
            # colors are readily specified in hex: ’RRGGBB’
            if style['color']:
                start += ‘<font color=»#%s«>’ % style['color']
                end = ‘</font>’ + end

Далее пересобрать с помощью скрипта build.bat проект и запустить инсталлер – теперь то что делает данный проект в  цвете отображается на хабре.

Октябрь 17, 2009. Метки: , , . .net, Blog, Live, Python. 1 комментарий.

Вы подготовились к приходу AutoMapper?

Введение

Данная статья предназначена к прочтению разработчикам и архитекторам распределенных систем на платформе .NET. В ней будет рассмотрен гибкий каркас для объектно-объектного преобразования (далее маппинга). Так же будут рассмотрены некоторые аспекты Domain-Driven Design’а.

Зачем мне нужен объектно-объектный маппинг?

Следуя основным принципам DDD, мы реализуем так называемую Rich Domain Model (эти объекты также должны соответствовать принципу POxO). Объекты реального мира, нашедшие отражение в нашем приложении частенько так же передают достаточную сложность, следовательно, достаточно корректно построенная модель крайне тяжело поддаётся перемещению между слоями приложения (не путать с легкостью вносимых изменений).

Data Transfer Object Тем не менее достаточно часто появляется необходимость “распределения” (я имею ввиду создание промежуточных сущностей, а не растекание модели по слоям) модели между слоями, для отображения, к примеру, атрибутов её сущностей пользователям (в шаблонах представления MVx), а так же передаче по сервисам (Data Transfer Object). Порой бывает даже, что модель “распределяется” для тестирования некоторых аспектов.

Предположим, мы в Африке, у нас банановая плантация, всё классно, выращиваем, продаём, выращиваем, продаём, но тут внезапно внутренний рынок переполняется и нам надо расширятся (к примеру вести бананы в Россию), мы пишем WCF сервис, который будет слать наши бананы. Так как бананы в Африке имеют несколько иное значение, чем в России, то, соответственно нам понадобятся лишь некоторые атрибуты (остальные фактически не имеют значения), которые мы забубеним в наш DTO

Правильнее было бы дать классу BananaWrapper название BananaDTO, для того, чтобы точно отображать его функциональное назначение, но я оставлю название таким для большего уровня абстракции, к примеру, если нам понадобится сделать автомат по продажи бананов и поместить этот объект в Presenter Model

Хочу заметить, что порой задача преобразования объектов становится довольно-таки нетривиальной и в лучшем случаем выглядит примерно подобным образом (это решение в лоб, есть ещё более изощренные методы ;) ):

  1. public class Banana
  2. {
  3. public string Country { get; set; }
  4. public double Price { get; set; }
  5. public int Age { get; set; }
  6. }
  8. public class BananaWrapper
  9. {
  10. public string Country { get; set; }
  11. public double Price { get; set; }
  12. public int Age { get; set; }
  13. }
  15. public class BananaMapper
  16. {
  17. public BananaWrapper GetWrapper(Banana banana)
  18. {
  19. return new BananaWrapper
  20. {
  21. Country = banana.Country,
  22. Price = banana.Price,
  23. Age = banana.Age
  24. };
  25. }
  26. }

* This source code was highlighted with Source Code Highlighter.

Думаю, что такой код писать, а тем более сопровождать, мало кому будет в радость, в последнее время я как раз частенько встречался с такого рода задачами, и находился в поиске решения проблемы.

AutoMapper

И тут на сцену выходит наш персонаж – AutoMapper, и сразу же говорит мне: – послушай, ты что такое пишешь? тебе не лень? ты не боишься допустить ошибок? хочешь я тебе помогу?!. Я конечно же соглашаюсь, и получаю в ответ следующее решение моей проблемы:

  1. public class BananaMapper
  2. {
  3. public BananaMapper()
  4. {
  5. Mapper.CreateMap<Banana, BananaWrapper>();
  6. }
  8. public BananaWrapper GetWrapper(Banana banana)
  9. {
  10. return Mapper.Map<Banana, BananaWrapper>(banana); ;
  11. }
  12. }

* This source code was highlighted with Source Code Highlighter.

Класс, и это действительно всё, что мне понадобится. Сложность, вышележащего примера снизилась в моих глазах до нуля.

Итак, что же за механизмы лежат внутри AutoMapper?

AutoMapper проверяет есть соответствующие поля в указанных типах, соответствие проводится как по имени свойства, так и по его типу. Даже такие нюансы, как Product.Name и ProductName будут учтены и обработаны автоматически (wow!). Плюс ко всему методы GetXXX() будут ложится на свойства XXX (да, ну и естественно для особо раздражительных все эти прелести можно отключить и переопределить всё в своих собственных таблицах соответствия (далее мапках)).

Кастомная конфигурация выглядит примерно следующим образом:

  1. Mapper.CreateMap<CalendarEvent, CalendarEventForm>()
  2. .ForMember(dest => dest.EventDate, opt => opt.MapFrom(src => src.EventDate.Date))
  3. .ForMember(dest => dest.EventHour, opt => opt.MapFrom(src => src.EventDate.Hour))
  4. .ForMember(dest => dest.EventMinute, opt => opt.MapFrom(src => src.EventDate.Minute));

* This source code was highlighted with Source Code Highlighter.

Кстати, все ваши кастомные конфигурации легко поддаются проверке с помощью следующего метода:

  1. Mapper.AssertConfigurationIsValid();

* This source code was highlighted with Source Code Highlighter.

Так же не плохо работает с:

История

Проект появился в конце’08-начале’09, около полугода находился в версии 0.31, сейчас же добрался до RC 1.0, думаю, что релиз уже совсем скоро.

Overhead?

banana Дебаты по поводу того, насколько быстрее будет работать AutoMapper и присвоение свойств в ручную (и прочие мульки) я игнорирую, т.к. готов пойти на любые жертвы производительности, если получу ясный, читабельный код. Ах, да, автор AutoMapper позаботился об этих вопросах и написал бенчмарки, смотреть здесь: http://code.google.com/p/automapperhome/source/browse/#svn/trunk/src/Benchmark

Ресурсы

Скачать проект, а так же ознакомиться с исходными кодами можно здесь: http://code.google.com/p/automapperhome/

Обсуждения каркаса здесь: http://groups.google.com/group/automapper-users

Так же примеры использования есть здесь: http://automapper.codeplex.com/

Кстати проект разрабатывает Jimmy Bogard, который так же пишет BDD фреймворк для .NET под названием NBehave.

Октябрь 8, 2009. Метки: , , , . .net, DDD, architecture. 3 comments.

DynamicObject, JSON и ближайшее будущее

Введение

В данной статье хочу ознакомить вас с небольшим приложением для работы с JSON данными, демонстрирующим возможности, доступные нам в .NET 4.0. Поверхностно будут рассмотрены вопросы JSON-формата, а так же работы с динамическими типами данных.

JSON

Есть такая классная шутка, известная широким массам:

3763158824_e2f57810c4[1] JSON (JavaScript Object Notation) – простой формат обмена данными, удобный для чтения и написания как человеком, так и компьютером. Он основан на подмножестве языка программирования JavaScript, определенного в стандарте ECMA-262 3rd Edition – December 1999. JSON – текстовый формат, полностью независимый от языка реализации, но он использует соглашения, знакомые программистам C-подобных языков, таких как C, C++, C#, Java, JavaScript, Perl, Python и многих других. Эти свойства делают JSON идеальным языком обмена данными. далее…

JSON и ваше приложение

Ну так вот, обычно, получая объекты по JSON в наших приложениях мы должны подготовить инфраструктуру для их поддержки (к примеру с помощью DataContractJsonSerializer и решения на типа этого). Однако это занимает значительное время у разработчика. В связи с этим у меня появилось страстное желание поставить JSON механизмы на рельсы динамических возможностей .NET 4.0 и получать от работы с ним одно удовольствие ;)

DynamicObject

DynamicObject – Предоставляет нам простой класс, наследуясь от которого мы можем получить динамическое поведение объекта на этапе исполнения. Наследуясь от этого класса и переопределяя некоторые его методы реализуется вся основная логика необходимая нам для этого.

Если хостинг DLR и прочие прелести вас заинтересовали и вы хотите ознакомиться немного поглубже с вопросом, то можно посмотреть наше выступление здесь, а так же слайды (здесь и здесь).

К разработке

Для того, чтобы не испытывать неудобств при работе с JSON, я предлагаю воспользоваться (слить и зареференсить) решением от James Newton под названием JSON.NET, данный проект свободен и удовлетворяет всем основным требованиям работы с JSON в рамках .NET-стека (в том числе и LINQ).

Да, к тому же нам понадобится IDE, умеющая работать с .NET 4.0b1, к примеру Visual Studio 2010 Beta 1 (кстати #develop не отстает).

Создаем наше приложение, которое будет выглядеть примерно следующим образом:

string input = @»{CPU: ’Intel’, Drives: ['DVD read/writer', 
""500 gigabyte hard drive""  ]}»;

dynamic computer = new DynamicJSON(input);

И пробуем посмотреть, какие же свойства обнаружатся у нашего компьютера:

>> computer.CPU
«Intel»

>> computer.Drives
[
  "DVD read/writer",
  "500 gigabyte hard drive"
]

>> computer.Drives[0]
«DVD read/writer»

Пока ничего необычного, учитывая, что мы не знаем, что же из себя представляет DynamicJSON, к реализации которого мы и обратимся за впечатлениями:

  using Newtonsoft.Json.Linq;

  public class DynamicJSON : DynamicObject
  {
    private JObject _data;

    public DynamicJSON(string data)
    {
      _data = JObject.Parse(data);
    }

    public override bool TryGetMember(GetMemberBinder binder, out object result)
    {
      result = _data[binder.Name];
      return true;
    }
  }

И это всё, что потребуется от нас для работы данного примера, меня подобные вещи радуют чрезмерно, в связи с чем рекомендую и вам использовать подобную практику в своих решениях.

Сентябрь 21, 2009. Метки: , , , , , . .net, DLR, JSON, dynamic. 1 комментарий.

Как забыть про ярлыки на рабочем столе?

Введение

image Раньше у меня довольно часто возникала проблема захламления рабочего стола огромным количеством ярлыков, и я начинал теряться в них, соответственно терять время при поиске необходимых мне приложений. В дальнейшем я научился пользоваться сочетанием клавиш win+r, создавая ярлыки с короткими именами в system32. С приходом Windows Vista (7) теперь только кнопки win, однако гибкость и настройка данных методов весьма ограниченна. Имеется так же огромное количество hotkey-менеджеров, однако не с одним из них я так и не сдружился.

Лаунчеры

Недавно (по-моему после прочтения книги «Продуктивный программист. Как сделать сложное простым, а невозможное – возможным» Нила Форда) мой интерес пал на launcher’ы. Для windows-платформы я нашёл несколько:

Ну и герой этого поста:

Немного истории

enso_321[1]

Изложу настолько, насколько я сумел разобраться в ней. Первоначально Enso был строго коммерческим проектом, разрабатываемым компанией Humanized (основанной Джеффри Раскиным, в котрой в последующем работал его сын). В дальнейшем компания начала работу над Mozilla Ubiquity (аналог Enso, являющийся плагином для FireFox), что позволило ей сделать Enso бесплатным.

Enso

Лучше 1 раз увидеть, чем 7 раз прочитать, базовые возможности представлены в следующих роликах:

На настоящий момент на сайте компании есть две версии продукта:

удобна в эксплуатации, но умеет делать лишь базовые вещи.

настройка (как и во второй версии) происходит через embeded веб-сервер

в данной версии появилось огромное количество очень полезных плагинов (к примеру поиск в google, генерация объектов-карт по выделенному адресу) однако юзабили немного упало (с моей точки зрения) в плане того, что после ввода команды начала открываться отдельная строка для ввода параметров, на что уходило время, и приходилось нажимать лишний раз enter

Все отлично, за исключением того, что проект на данном сайте вроде как заброшен, что не совсем воодушевляло к использованию, однако слазив внутрь и посмотрев реализацию, обнаружилось, что всё написано на Python (межплатформенность?), а так же исходники доступны в свободном доступе, что немного приободрило.

В дальнейших поисках упоминаний о Enso я наткнулся на коммунити http://www.ensowiki.com, а так же (самое главное) хостинг нынешей версии Enso https://launchpad.net/enso, итак, что же изменилось с тех времен:

  • настройка больше не через веб-сервер
  • межплатформенность (Windows, Linux, Mac OS X, etc)
  • интерфейс первой версии
  • практически все плагины из второй версии

Используем Enso

Для установки существует инсталлер, поэтому трудности вряд ли могут встретиться. Далее у меня возникла необходимость в настройке (теперь для совершения настроек существует файл enso\config.py) “основной” клавиши (Caps Lock) в режим залипания (Sticky в терминологии создателей программы), для этого я проделал следующее:

# Whether the Quasimode is actually modal («sticky»).

IS_QUASIMODE_MODAL = True

Расширяем Enso

Классно, мой питомец (Enso) теперь стал послушным и ласковым, однако хочется научить его понимать новые команды, ну что ж, пускай это будет Enso hello world.

Я отправился в папку commands в корне, куда добавил файл butaji.py со следующим содержимым:

import enso.config

from enso.messages import displayMessage

def cmd_butaji(ensoapi, cmd):

if cmd == «time»:

ensoapi.display_message(«Hello world»)

cmd_butaji.valid_args = ['time']

И у меня получилось следующее:

image

image

Великолепно! я думаю, что мы с Enso очень сдружимся.

Сентябрь 7, 2009. Метки: , , , , . Productive, Python. 1 комментарий.

Ещё раз о SharePoint Guidance

Небольшая заметка, в которой я в очередной раз хотел бы обратить внимание на следующий документ:

sharepoint_guidance[1]

patterns & practices SharePoint Guidance

исключительно рекомендую всем разработчикам SharePoint

А так же вчера на http://channel9.msdn.com/ вышло несколько роликов, о работе с эти проектом:

How to use the logging components? – p & p Developing SharePoint Applications guidance

How to use the configuration component? – p & p Developing SharePoint Applications guidance

How to use the SharePoint Service Locator? – p & p Developing SharePoint Applications guidance

Walkthrough of the Contoso Reference Implementation- p & p Developing SharePoint Applications guidance

Приятного просмотра.

Сентябрь 3, 2009. Метки: , , , . sharepoint. Оставить комментарий.

Анализ рынка ноутбуков с помощью Python

Введение

В этой статье я расскажу о состоянии на сегодняшнем российском рынке ноутбуков. Всю аналитику мы будем проводить с помощью кода на python. Думаю она будет полезна как тем, кто ищет ноутбук, так и тем, кто хочет потренироваться написанию на python.

Начнём

diy-03-425[1] Для анализа нам необходим набор данных, к сожалению я не смог обнаружить веб-сервисы у российских он-лайн магазинов ноутбуков, поэтому мне пришлось скачать прайс-лист одного из них (я не стану называть его) и вытащить из него цены и основные параметры (по-моему мнению таковыми являются: частота процессора, диагональ монитора, объем оперативной памяти, размер жесткого диска и объем памяти на видео-карточке). Далее я провёл некоторый анализ по следующим вопросам:

  1. Средняя стоимость ноутбука
  2. Усредненные параметры железа на ноутбуках
  3. Самая дорогая/дешевая конфигурация ноутбука
  4. Какой из параметров конфигурации больше всего влияет на его цену
  5. Прогнозирование цены указанной конфигурации
  6. График распределения конфигураций и цен

Lets code

Прайс-лист, который мне удалось заполучить я сохранил в формате CVS, для работы с ним необходимо подключить модуль cvs:

import csv
import re
import random

Так же подключим модуль для работы со случайными числами и регулярными выражениями, которые в последствии нам понадобятся.

Далее создадим метод для чтения и получения ноутбуков:

def get_notebooks():
    reader = csv.reader(open(‘data.csv’), delimiter=‘;’, quotechar=‘|’)
    return filter(lambda x: x != None, map(create_notebook, reader))

здесь всё просто, мы читаем на файл с данными data.csv и фильтруем по результату функции create_notebook, т.к. не все позиции в прайсе являются ноутбуками, а вот кстати и она:

def create_notebook(raw):
    try:
        notebook = Notebook()
        notebook.vendor = raw[0].split(‘ ’)[0]
        notebook.model = raw[0].split(‘ ’)[1]
        notebook.cpu = getFloat(r»(\d+)\,(\d+)\s\Г», raw[0].split(‘/’)[0])
        notebook.monitor = getFloat(r»(\d+)\.(\d+)\»», raw[0].split(‘/’)[1])
        notebook.ram = getInt(r»(\d+)\Mb», raw[0].split(‘/’)[2])
        notebook.hdd = getInt(r»(\d+)Gb», raw[0].split(‘/’)[3])
        notebook.video = getInt(r»(\d+)Mb», raw[0].split(‘/’)[4])
        notebook.price = getInt(r»(\d+)\s\руб.», raw[1])
        return notebook
    except Exception, e:
        return None

Как вы можете заметить, я решил не обращать внимания на вендора, модель и тип процессора (здесь конечно не всё так просто, но тем не менее), а и ещё – в данном методе присутствуют мои кастомные функции-помощники:

def getFloat(regex, raw):
    m = re.search(regex, raw).groups()
    return float(m[0] + ‘.’ + m[1])

def getInt(regex, raw):
    m = re.search(regex, raw).groups()
    return int(m[0])

Хочу заметить, что писать для питона лучше всего в стиле наборов данных, а не ООП структур, в связи с тем, что язык больше располагает к такому стилю, однако для наведения некоторого порядка в нашей доменной области (ноутбуки), я ввёл класс, как вы могли заметить выше (notebook = Notebook())

class Notebook:
   pass

Отлично, теперь у нас есть структура в памяти и она готова для анализа (2005 различных конфигураций и их стоимость), что же начнём:

Средняя стоимость ноутбука:

def get_avg_price():
    print sum([n.price for n in get_notebooks()])/len(get_notebooks())

Исполняем код и видим, что 1K$, как стандарт для компьютера всё ещё в силе:

>> get_avg_price()
34574

Усредненные параметры железа на ноутбуках

def get_avg_parameters():
    print «cpu {0}».format(sum([n.cpu for n in get_notebooks()])/len(get_notebooks()))
    print «monitor {0}».format(sum([n.monitor for n in get_notebooks()])/len(get_notebooks()))
    print «ram {0}».format(sum([n.ram for n in get_notebooks()])/len(get_notebooks()))
    print «hdd {0}».format(sum([n.hdd for n in get_notebooks()])/len(get_notebooks()))
    print «video {0}».format(sum([n.video for n in get_notebooks()])/len(get_notebooks()))

Та-да, и в наших руках усредненная конфигурация:

>> get_avg_parameters()
cpu 2.0460798005
monitor 14.6333167082
ram 2448
hdd 243
video 289

Самая дорогая/дешевая конфигурация ноутбука:

Функции идентичны, за исключением функций min/max

def get_max_priced_notebook():
    maxprice = max([n.price for n in get_notebooks()])
    maxconfig = filter(lambda x: x.price == maxprice, get_notebooks())[0]
    print «cpu {0}».format(maxconfig.cpu)
    print «monitor {0}».format(maxconfig.monitor)
    print «ram {0}».format(maxconfig.ram)
    print «hdd {0}».format(maxconfig.hdd)
    print «video {0}».format(maxconfig.video)
    print «price {0}».format(maxconfig.price)
>> get_max_priced_notebook()
cpu 2.26
monitor 18.4
ram 4096
hdd 500
video 1024
price 181660
>> get_min_priced_notebook()
cpu 1.6
monitor 8.9
ram 512
hdd 8
video 128
price 8090

Какой из параметров конфигурации больше всего влияет на его цену

Очень интересно было бы узнать, за какой из параметров конфигурации мы платим больше всего денег. Прикинув, я предположил, что скорее всего это диагональ монитора и частота процессора, ну что же, думаю, что стоит проверить это.

Для начала наш набор параметров конфигурации стоит немного модифицировать. В связи с тем, что единицы измерения различных параметров различны в своём порядке, нам необходимо привести их к одному знаменателю, т.е. нормализовать их. Итак, приступим:

def normalized_set_of_notebooks():
    notebooks = get_notebooks()
    cpu = max([n.cpu for n in notebooks])
    monitor = max([n.monitor for n in notebooks])
    ram = max([n.ram for n in notebooks])
    hdd = max([n.hdd for n in notebooks])
    video = max([n.video for n in notebooks])
    rows = map(lambda n : [n.cpu/cpu, n.monitor/monitor, float(n.ram)/ram, float(n.hdd)/hdd, float(n.video)/video, n.price], notebooks)
    return rows

В данной функции я нахожу максимальные значения для каждого из параметров, после этого формирую результирующий список ноутбуков, в котором каждый из параметров представлен в виде коэффициента (его значение будет колебаться от 0 до 1), показывающего отношение его параметра к максимальному значению в наборе, к примеру память в 2048Mb даст конфигурации коэффициент в ram = 0.5 (2048/4056).

Вклад каждого из параметров мы будем считать в рублях, для наглядности, хранить эти веса мы будет в наборе:

#cpu, monitor, ram, hdd, video
koes = [0, 0, 0, 0, 0]

Я предлагаю исчислять эти коэффициенты для каждой конфигурации, а после этого определить среднюю величину всех коэффициентов, что даст нам усредненные данные о весе каждого из элементов конфигурации.

def analyze_params(parameters):
    koeshistory = []
    #наши ноутбуки
    notes = normalized_set_of_notebooks()
    for i in range(len(notes)):
        koes = [0, 0, 0, 0, 0]
        #устанавливаем коэффициенты
        set_koes(notes[i], koes)
        #сохраняем историю коэффициентов
        koeshistory.extend(koes)
        #показываем прогресс выполнения
        if (i % 100 == 0):
            print i
            print koes

Как же мы будет устанавливать коэффициенты для каждого элемента конфигурации? Мой способ заключается в следующем:

  • нам необходимо в случайном порядке наращивать, либо уменьшать значение одного из коэффициентов
  • после чего анализировать, приблизились ли мы к цене за конфигурацию, при умножении вектора параметров на вектор коэффициентов (напомню, что в нашем случае это рубли)
  • если приближение состоялось, ты мы повторяем данное действие, если же нет, то отменяем его
  • повторять данный порядок до той степени, пока не приблизимся к нашей цене с установленной нами точностью

Вот реализация данного алгоритма:

def set_koes(note, koes, error=500):
    price = get_price(note, koes)
    lasterror = abs(note[5] - price)
    while (lasterror > error):
        k = random.randint(0,4)
        #изменяем коэффицинт
        inc = (random.random()*2 - 1) * (error*(1 - error/lasterror))
        koes[k] += inc
        #не даём коэффициенту стать меньше нуля
        if (koes[k] < 0): koes[k] = 0
        #получаем цену при учёте коэффициентов
        price = get_price(note, koes)
        #получаем текущую ошибку
        curerror = abs(note[5] - price)
        #проверяем, приблизились ли мы к цене, казанной в прайсе
        if (lasterror < curerror):
            koes[k] -= inc
        else:
            lasterror = curerror

inc – переменная отвечающая за цвеличение/уменьшение коэффициента, способ её вычисления объесняется тем, что данное значение должно быть тем больше, чем больше разница в ошибке, для быстрого и более точного приближения к желаемому результату.

Умножение векторов для получения цены выглядит следующим образом:

def get_price(note, koes):
    return sum([note[i]*koes[i] for i in range(5)])

Пришла пора выполнить анализ:

>> analyze_params()
cpu, monitor, ram, hdd, video

[15455.60675667684, 20980.560483811361, 12782.535270304281, 17819.904629585861, 14677.889529808042]

Данный набор мы получили, благодаря усреднению коэффициентов, полученных для каждой из конфигураций:

def get_avg_koes(koeshistory):
    koes = [0, 0, 0, 0, 0]
    for row in koeshistory:
        for i in range(5):
            koes[i] += koeshistory[i]
    for i in range(5):
        koes[i] /= len(koeshistory)
    return koes

Итак, у нас получился желаемый набор, что же мы можем сказать из этих цифр, а можем мы составить рейтинг параметров:

  1. Диагональ монитора
  2. Объем жесткого диска
  3. Частота процессора
  4. Объем видео-карточки
  5. Объем оперативной памяти

Хотелось бы отметить, что это далеко не идеальный вариант, и у вас могут получится иные результаты, однако, моё предположение, о том, что частота процессора и диагональ дисплея наиболее важные параметры в конфигурации, частично подтвердились.

Прогнозирование цены указанной конфигурации

Классно бы было, имея такой богатый набор данных, уметь прогнозировать цену на заданную конфигурацию. Этим мы и займемся.

Для начала преобразуем нашу коллекцию ноутбуков в список:

def get_notebooks_list():
    return map(lambda n: [n.cpu, n.monitor, n.ram, n.hdd, n.video, n.price], get_notebooks())

Далее нам понадобиться функция, способная определить расстояние между двумя векторами, хорошим вариантом я вижу функцию эвклидова расстояния:

def euclidean(v1, v2):
    d = 0.0
    for i in range(len(v1)):
        d+=(v1[i] - v2[i])**2;
    return math.sqrt(d)

Корень из суммы квадратов разностей довольно таки наглядно и эффективно показывает нам насколько один вектор различен от другого. Чем же полезна для нас данная функция? Всё просто, когда мы получим вектор, с интересующими нас параметрами, мы пробежимся по всей коллекции нашего набора и найдём ближайшего соседа, а его стоимость мы уже знаем, отлично! Вот как мы это сделаем:

def getdistances(data, vec1):
    distancelist=[]
    for i in range(len(data)):
        vec2 = data[i]
        distancelist.append((euclidean(vec1,vec2),i))
    distancelist.sort()
    return distancelist

Далее, можно немного усложнить задачу, а так же точность предоставляемых данных. Для этого мы введем функцию, использующую классификацию методом k взвешенных ближайших соседей:

K взвешенных ближайших соседей – это метрический алгоритм классификации, основанный на оценивании сходства объектов. Классифицируемый объект относится к тому классу, которому принадлежат ближайшие к нему объекты обучающей выборки.

Ну и взять среднее значение среди некоторого количества ближайших соседей, что сведет на нет влияние цен вендора, либо специфичности конфигурации:

def knnestimate(data,vec1,k=3):
    dlist = getdistances(data, vec1)
    avg = 0.0
    for i in range(k):
        idx = dlist[i][1]
        avg +=data[idx][5]
    avg /= k
    return avg

*последние 3 алгоритма взяты из книги Сегерана Тоби “Программируем коллективный разум”

И что же мы получаем:

>> knnestimate(get_notebooks_list(), [2.4, 17, 3062, 250, 512])
31521.0

>> knnestimate(get_notebooks_list(), [2.0, 15, 2048, 160, 256])
27259.0
>> knnestimate(get_notebooks_list(), [2.0, 15, 2048, 160, 128])
20848.0

Цены рыночные и этого вполне достаточно, хотя мы абсолютно не учитываем в этой реализации, к примеру частоту процессора и диагональ монитора (для этого нам необходимо добавить в функцию сравнения векторов их веса , которые мы вычисляли в предыдущем пункте)

График распределения конфигураций и цен

Хочется объять картину распределения целиком, т.е. нарисовать распределение конфигураций и цен на рынке. Ок, сделаем это.

Для начала надо поставить библиотеку matplotlib. Далее подключить её к нашему проекту:

from pylab import *

Так же нам понадобится создать два набора данных, для оси абсцисс и ординат:

def power_of_notebooks_config():
    return map(lambda x: x[0]*x[1]*x[2]*x[3]*x[4], normalized_set_of_notebooks())
def config_prices():
    return map(lambda x: x[5], normalized_set_of_notebooks())

И функцию, в которой мы построим график распределения:

def draw_market():
    plot(config_prices(),power_of_notebooks_config(),‘bo’, linewidth=1.0)

    xlabel(‘price (Rub)’)
    ylabel(‘config_power’)
    title(‘Russian Notebooks Market’)
    grid(True)
    show()

И что же мы получаем:

notes

В завершение

Итак, у нас получилось провести небольшой анализ российского рынка ноутбуков, а так же немного проиграться с python.

Исходный код проекта доступен по адресу:

http://code.google.com/p/runm/source/checkout

Август 31, 2009. Метки: , , , , , . DataMining, Notebook, Price, Python. Оставить комментарий.

Ruby|Python в браузере, сделай сам

Зачем?

sidebar_gestaltКлиентскую часть в веб-приложениях принято создавать на JavaScript. Я считаю, что большинство разработчиков с огромным удовольствием бы отошли от этого правила и воспользовались своим любимым server-side языком. Ну что же, команда MIX Online предоставила любителям динамических языков такую возможность, подробнее об этом можно прочитать в “Проект Gestalt – пишите на Ruby, Python и XAML прямо в HTML на стороне клиента”. Ниже я предлагаю создать нечто подобное, но уже своими силами.

С помощью чего?

Посмотрев несколько примеров мне стало ясно, что реализован Gestalt на Silverlight + Dynamic Languages Runtime. Далее я прикинул, а на сколько сложно создать нечто своими руками? И сразу же решение: Silverlight умеет  взаимодействовать с DOM – значит я смогу получить код и интерпритировать его – дело за малым – реализация.

Приступим

Нам понадобятся:

  • Visual Studio >2008SP1 (при желании можно и другие IDE или средства редактирования текста)
  • Silverlight >2.0 Tools
  • Dynamic Languages SDK >0.5.0 (download)
  • 10 мин времени

Lets code

image

Открываем Visual Studio, создаём Silverlight Application, я назову проект “mygestalt”. Теперь я осознаю, что писать та надо будет совсем не много, мне понадобится экспериментальный Client-Script и его интерпритатор. Открываем страничку, на которой будет хоститься наш Silverlight, в моём случаем это mygestaltTestPage.aspx и добавляем туда наш client-side python code. Выглядеть это должно примерно так:

  1. <script type="python">
  2. def func():
  3.     HtmlPage.Window.Alert("Hello world!")
  4.    
  5. func()
  6. </script>

* This source code was highlighted with Source Code Highlighter.

Далее отправляемся в MainPage.xaml.cs, где будем заниматься поисками нашего скрипта:

  1. using System.Linq;
  2. using System.Windows.Browser;
  3.  
  4. namespace mygestalt
  5. {
  6.   public partial class MainPage
  7.   {
  8.     public MainPage()
  9.     {
  10.       InitializeComponent();
  11.       FindAndRunScript();
  12.     }
  13.  
  14.     private void FindAndRunScript()
  15.     {
  16.       var scripts = HtmlPage.Document.GetElementsByTagName("script");
  17.       var pythonScript = scripts.Where(x => x.GetProperty("type").ToString() == "python").First();
  18.       PythonEngine.Run(pythonScript.GetProperty("innerHtml").ToString());
  19.     }
  20.   }
  21. }

* This source code was highlighted with Source Code Highlighter.

Ну и реализация PythonEngine:

  1. using Microsoft.Scripting;
  2. using Microsoft.Scripting.Hosting;
  3. using Microsoft.Scripting.Silverlight;
  4.  
  5. namespace mygestalt
  6. {
  7.   public static class PythonEngine
  8.   {
  9.     public static ScriptScope Run(string source)
  10.     {
  11.       var setup = Configuration.LoadFromAssemblies(Package.GetManifestAssemblies());
  12.       setup.HostType = typeof(BrowserScriptHost);
  13.       setup.DebugMode = true;
  14.       var runtime = new ScriptRuntime(setup);
  15.       var engine = runtime.GetEngine("IronPython");
  16.       var scope = engine.CreateScope();
  17.       const string init = @"
  18. import clr
  19. clr.AddReference('System.Windows.Browser')
  20.  
  21. from System.Windows.Browser import *
  22.  
  23. "

    24. ;

  24.  
  25.       ScriptSource initSource = engine.CreateScriptSourceFromString(init, SourceCodeKind.Statements);
  26.       initSource.Execute(scope);
  27.       var script = engine.CreateScriptSourceFromString(source, SourceCodeKind.Statements);
  28.       script.Execute(scope);
  29.  
  30.       return scope;
  31.     }
  32.   }
  33. }

* This source code was highlighted with Source Code Highlighter.

Запускаем приложение и видим:

image

 

 

 

 

В заключение

Вот у нас и получился свой собственный Gestalt, самое интересное в том, что я посмотрел его исходники и нашёл там примерно такую же реализацию.

Мой проект можно найти на http://code.google.com/p/mygestalt/.

Всем спасибо!

Август 1, 2009. Метки: , , , , , , . DLR, Python, Ruby, javascript, silverlight. Оставить комментарий.

Следующая страница »