peterrenshaw / socsim Goto Github PK

                                _          
     _____ ____   _____  _____ (_)____ ___ 
    / ___// __ \ / ___/ / ___// // __ `__ \
   (__  )/ /_/ // /__  (__  )/ // / / / / /
  /____/ \____/ \___/ /____//_//_/ /_/ /_/ [1] 



  name readme.txt
  date 2013AUG04
  prog @peterrenshaw
  desc SOCSIM: A simulation tool for social media to test against.


2013AUG17
* install
- python2.7 OK - all 54 tests pass
- python3.2 OK - all 54 tests pass
* trivial (in|ex)clusions
- .gitignore
- setup.py
* rebuild source code tree
* create install script
* make sure tests, hacks code work
* update docs

2013AUG15
* record/factory.Factory
- done, tested
* record/hack_read_ini2json.py
- run, not tested but naive test works
* input
- urls.ini
* output
- urls.json
* HACK_Factory.txt, written
- rough version

2013AUG13
* record/factory.py
- added
+ factory.Ini
+ empty.ini
+ contact.ini
+ urls.ini

* work on factory.Ini allows to specificy blocks
  as .ini files on system. Read them & then push
  thu work chain
 
    file.ini <- factory.Ini.read()
    factory.Ini.all() -> factory.Delivery
 
    Delivery.Meta for blocks
    Delivery.Record as container for blocks

* record/test_ini.py
- attention to versions of python and
  using configparser which changes sig
  for python version 3
- attention to different operating system
  filepaths
* record/test_all
- updated

2013AUG11
* added HACK_INI.txt
- describes how .ini files are used
* added hack_read_ini.py
- quick, untested hack to see how configparser works
  and how this might be used to read .ini files
- idenified problems with python versions
- no real code yet, just a hack to see where to 
  go next.

2013AUG10
* record.Meta
- basic testing against record/record.py
+ added record/test_tools.py
+ ammeded record/test_all.py
- all: fixes
- __add_default: added time format string setting
* testing
- record.Meta
+ fixes
- record.Record() done

2013AUG09
* added license
- <https://www.gnu.org/licenses/gpl-3.0.txt>

* couple of changes
- blocks.py
+ example code
- record.py
+ comment blocks added

* idea: like most ideas they take time to develop. This is how the idea stands as of now:
- we have blocks of metadata and a record block.
- a Record block contains a list of key/value pairs
- so a key/value pair can contain a Meta block with all the associated metadata.
- I like to think of these as lego like blocks that can be stacked together.
- so we have

    Record KEY
           title
           description   
           created
           ...
           n unique key/value pairs        
           ...

    Meta KEY
         title
         description
         created
         ...
         n unique key/value
         ...

* Combining
- so we can now combine Meta blocks with a Record block be creating a unique Meta block
  populating it with data

      # a red block of size 2, with 2x2 holes and weighs 10g
      meta_a = record.Meta("A", "This is the A meta block")
      meta_a.add("colour", "red")
      meta_a.add("size", 2)
      meta_a.add("weight", 10)
      meta_a.add("format", "2x2")

      # data looks like this
      meta_a.all()
      {
        "deleted": false,
        "key": "A",
        "value": [
            {
                "key": "title",
                "value": "A"
            },
            {
                "key": "description",
                "value": "This is the A meta block"
            },
            {
                "key": "created",
                "value": "2013AUG0914:54"
            },
            {
                "key": "colour",
                "value": "red"
            },
            {
                "key": "size",
                "value": 2
            },
            {
                "key": "weight",
                "value": 10
            },
            {
                "key": "format",
                "value": "2x2"
            }
        ]
      }


      # a yellow block of size 4, with 2x4 holes and weighs 20g
      meta_b = record.Meta("B", "This is the B meta block")
      meta_b.add("colour", "yellow")
      meta_b.add("size", 4)
      meta_b.add("weight", 20)
      meta_b.add("format", "2x4")
      
      # data looks like this
      meta_b.all()
      {
        "deleted": false,
        "key": "B",
        "value": [
            {
                "key": "title",
                "value": "B"
            },
            {
                "key": "description",
                "value": "This is the B meta block"
            },
            {
                "key": "created",
                "value": "2013AUG0914:54"
            },
            {
                "key": "colour",
                "value": "yellow"
            },
            {
                "key": "size",
                "value": 4
            },
            {
                "key": "weight",
                "value": 20
            },
            {
                "key": "format",
                "value": "2x4"
            }
        ]
      }


      # a blue block of size 1, with 1x1 holes and weighs 5g
      meta_c = record.Meta("C", "This is the C meta block")
      meta_c.add("colour", "blue")
      meta_c.add("size", 1)
      meta_c.add("weight", 10)
      meta_c.add("format", "1x1")

      # data looks like this
      meta_c.all()
      {
        "deleted": false,
        "key": "C",
        "value": [
            {
                "key": "title",
                "value": "C"
            },
            {
                "key": "description",
                "value": "This is the C meta block"
            },
            {
                "key": "created",
                "value": "2013AUG0914:54"
            },
            {
                "key": "colour",
                "value": "blue"
            },
            {
                "key": "size",
                "value": 1
            },
            {
                "key": "weight",
                "value": 10
            },
            {
                "key": "format",
                "value": "1x1"
            }
        ]
      }


* with me still?
- now I want to create a big block, called Blocks.

     # create a big block called Blocks and add block a, b & c together

     labels = record.Meta("bigblock", "This is a big block made up of A, B & C blocks")
     Blocks = record.Record(labels.all()

     Blocks.add("A", meta_a.all())
     Blocks.add("B", meta_b.all())
     Blocks.add("C", meta_c.all())

     # what does it look like?
     Blocks.all()
     [
      {
        "key": "title",
        "value": "bigblock"
      },
      {
        "key": "description",
        "value": "This is block is combined with A, B, C"
      },
      {
        "key": "created",
        "value": "2013AUG0914:54"
      },
      {
        "deleted": false,
        "key": "A",
        "value": [
            {
                "key": "title",
                "value": "A"
            },
            {
                "key": "description",
                "value": "This is the A meta block"
            },
            {
                "key": "created",
                "value": "2013AUG0914:54"
            },
            {
                "key": "colour",
                "value": "red"
            },
            {
                "key": "size",
                "value": 2
            },
            {
                "key": "weight",
                "value": 10
            },
            {
                "key": "format",
                "value": "2x2"
            }
        ]
      },
      {
        "deleted": false,
        "key": "B",
        "value": [
            {
                "key": "title",
                "value": "B"
            },
            {
                "key": "description",
                "value": "This is the B meta block"
            },
            {
                "key": "created",
                "value": "2013AUG0914:54"
            },
            {
                "key": "colour",
                "value": "yellow"
            },
            {
                "key": "size",
                "value": 4
            },
            {
                "key": "weight",
                "value": 20
            },
            {
                "key": "format",
                "value": "2x4"
            }
        ]
      },
      {
        "deleted": false,
        "key": "C",
        "value": [
            {
                "key": "title",
                "value": "C"
            },
            {
                "key": "description",
                "value": "This is the C meta block"
            },
            {
                "key": "created",
                "value": "2013AUG0914:54"
            },
            {
                "key": "colour",
                "value": "blue"
            },
            {
                "key": "size",
                "value": 1
            },
            {
                "key": "weight",
                "value": 10
            },
            {
                "key": "format",
                "value": "1x1"
            }
        ]
      }
    ]

* now we can save this as a file and use it a lot of different ways on the web, and that's good.

2013AUG06
* todo
- added 

2013AUG05
* docs/resources.md
- quick exploration on how/why u might store critical data
- make distinction between human/machine readable format
- storage, resource types, access & distribution

* docs/testing.md
- quick ideas on what to test on responses

2013AUG04
* docs/simple.md
- a quick decription of a scenario
- how it's done on pen/paper & twitter
- conducting experiments, what can you measure?
- how to improve thru automat@n
- sanity check

* updated about - scenario, controller, operators, time, fog, analysis
* screw markdown, remove ABOUT.md, convert to .txt
* github remote add
* wrote about cf ABOUT.md
* created


[1] Title created with an ASCII text generator using 'slant' and 'stretch=Yes". 
The code is based on Figlet which can be found here ~ <http://www.figlet.org/>
[Last accessed: Sunday 4th August, 2013]
<http://www.network-science.de/ascii/>


# vim: ff=unix:ts=4:sw=4:tw=78:noai:expandtab