コード例 #1
0
ファイル: centroids.py プロジェクト: catLyg/GeoLifeReader
logger = logging.getLogger("geolife")
#stdout = logging.StreamHandler()
#stdout.setLevel(logging.INFO)
#logger.addHandler(stdout)

from utils import ETACalculator
from schema import get_users
from schema import RecordsOnOneDay
import argparse
from sqlalchemy.sql import func
from sqlalchemy import Index
import csv
from raw import record

import config
engine = config.getEngine()

from sqlalchemy.orm import sessionmaker
Session = sessionmaker()
Session.configure(bind=engine)


def get_arguments():
    parser = argparse.ArgumentParser(
        description='Extract centroids of user movements.')
    parser.add_argument(
        '-t',
        '--dry-run',
        dest="dry_run",
        action="store_true",
        help=('Boolean indicator controlling if data should be added to the'
コード例 #2
0
ファイル: raw2db.py プロジェクト: Oracleli/GeoLifeReader
if __name__ == "__main__":
  args = get_arguments()
  directory = args.input_directory
  logger.info("Loading database with raw Geolife records")
  
  if args.weekday is None:
    logger.info("All weekdays")
    weekday = None

  else:
    weekday = int(args.weekday)
    logger.info("Weekday: {0}".format(record.WEEKDAY_STRINGS[weekday]))

  logger.info("Source:  {0}".format(directory))
  
  engine = config.getEngine()

  Session = sessionmaker()
  Session.configure(bind=engine)
  session = Session()
  logger.info("-"*50)
  logger.info("Database will be created and populated from files"
              " in {0}".format(directory))
  record.initialize_table(engine)
  logger.info("Table initialized")

  timer = ETACalculator(iterations=geolife.get_num_files(directory))
  user_weekday_counts = defaultdict(int)
  for u in user.from_directory(directory):
    logger.info("Beginning yielding of records from user {0.id}".format(u))
    for f in u.files:
コード例 #3
0
ファイル: schema.py プロジェクト: catLyg/GeoLifeReader
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy import Column
from sqlalchemy import Integer
from sqlalchemy import BigInteger
from sqlalchemy import Float
from sqlalchemy import Time
from sqlalchemy import Table

from sqlalchemy import MetaData
metadata = MetaData()
import config
RecordsOnOneDay = Table('day_records_view',
                        metadata,
                        autoload=True,
                        autoload_with=config.getEngine())

Base = declarative_base()


class HomogenizedRecord(Base):
    __tablename__ = "time_homogenized"
    id = Column(Integer, primary_key=True)
    user = Column(BigInteger)  #, index=True)
    latitude = Column(Float)
    longitude = Column(Float)
    time = Column(Time)

    def __repr__(self):
        return "<HomogenizedTimeRecord(name={0}, (x,y)=({1}, {2}), time={3})>".format(
            self.user, self.latitude, self.longitude, self.time)
コード例 #4
0
ファイル: drop_tables.py プロジェクト: catLyg/GeoLifeReader
from raw.record import GeoLifeUser
from raw.record import RawRecord
from schema import HomogenizedRecord
from schema import HomogenizedGeoLifeUser
from sqlalchemy import create_engine
from config import getEngine

engine = getEngine()
GeoLifeUser.__table__.drop(engine, checkfirst=True)
engine.execute("DROP VIEW day_records_view;")
RawRecord.__table__.drop(engine, checkfirst=True)
HomogenizedGeoLifeUser.__table__.drop(engine, checkfirst=True)
HomogenizedRecord.__table__.drop(engine, checkfirst=True)
コード例 #5
0
ファイル: db2one.py プロジェクト: Oracleli/GeoLifeReader
import argparse
from utils import timerange
from utils import ETACalculator
from utils import num_elements_in_time_range
from datetime import time
from datetime import timedelta
from sqlalchemy.orm import sessionmaker
import os
from one import ExternalMovementReaderConverter
from utils import timeDifferenceSeconds
import messages
import pystache
import csv

Session = sessionmaker()
engine = getEngine()
Session.configure(bind=engine)


# Parse the command-line arguments.
def get_arguments():
  parser = argparse.ArgumentParser(
    description='Write out files for simulation.'
  )
  parser.add_argument(
    '-d', '--time-delta',
    dest='time_delta',
    help="Number of seconds that should be between any two consecutive records",
    type=lambda x: timedelta(seconds=int(x)),
    default=timedelta(seconds=5),
  )