weekorm.model - Code Metrics - mitrofun/weakorm - Measure and Improve Code Quality continuously with Scrutinizer

weekorm.model D
last analyzed 2018-09-01 21:11 UTC

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	280
Duplicated Lines	0 %

Importance

Changes

Metric	Value
eloc	227
dl	0
loc	280
rs	4.08
c	0
b	0
f	0
wmc	59

31 Methods

Rating	Name	Size	Complexity
A	Model.get()	4	1
A	Query.all()	10	2
A	Query.__init__()	5	1
A	Model.__init__()	10	3
A	Model.field_values()	13	5
A	Model.query()	4	1
A	Field.field_sql()	7	3
A	Model.delete()	5	1
A	Field.to_python()	5	2
A	Query.__repr__()	2	1
A	Model.__str__()	2	1
A	IntegerField.__init__()	5	1
A	Model.update()	12	2
A	Model.field_names()	8	3
A	Query.query_sql()	4	1
A	Model.insert()	12	1
A	Query.filter()	12	5
A	Model.try_create_table()	21	4
A	ForeignKey.__init__()	5	1
A	CharField.__init__()	6	1
A	Query.field_names()	8	3
A	DateTimeField.__init__()	5	1
A	FloatField.__init__()	5	1
A	ForeignKey.field_sql()	2	1
A	Model.__repr__()	2	1
A	Query.__str__()	2	1
A	Query.first()	11	2
A	BooleanField.__init__()	5	1
A	Query.delete()	5	1
A	Model.save()	6	2
A	Query._r2ob()	15	5

How to fix Complexity

from datetime import datetime
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

from weekorm import db


class Field:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    field_type = ''
    default = ''
    is_foreign_key = False
    unique = False
    not_null = False
    python_type = str

    def field_sql(self, field_name):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        field_sql = f'"{field_name}" {self.field_type}'
        if self.unique:
            field_sql += ' UNIQUE'
        if self.not_null:
            field_sql += ' NOT NULL'
        return field_sql

    def to_python(self, value):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if self.python_type == datetime:
            value = datetime.fromtimestamp(value)
            return value
        return self.python_type(value)


class CharField(Field):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    def __init__(self, max_length=255, default='', unique=False):
        self.field_type = f'varchar({max_length})'
        self.default = default
        self.max_length = max_length
        self.unique = unique
        self.python_type = str


class IntegerField(Field):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    def __init__(self, default=0, unique=False):
        self.field_type = 'integer'
        self.default = default
        self.unique = unique
        self.python_type = int


class FloatField(Field):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    def __init__(self, default=0.0, unique=False):
        self.field_type = 'real'
        self.default = default
        self.unique = unique
        self.python_type = float


class BooleanField(Field):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    def __init__(self, default=False, unique=False):
        self.field_type = 'integer'
        self.default = default
        self.unique = unique
        self.python_type = bool


class DateTimeField(Field):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    def __init__(self, default=0.0, unique=False):
        self.field_type = 'real'
        self.default = default
        self.unique = unique
        self.python_type = datetime


class ForeignKey(Field):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
    def __init__(self, model_class):
        self.field_type = 'foreignkey'
        self.is_foreign_key = True
        self.model_class = model_class
        self.python_type = int

    def field_sql(self, field_name):
        return f'"{field_name}" integer REFERENCES "{self.model_class.__name__.lower()}" ("id")'


class Model:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    def __init__(self, inst_id=0, **kwargs):
        self.table_name = self.__class__.__name__.lower()
        self.id = inst_id

        self.__class__.try_create_table()

        for name in self.field_names:
            field = getattr(self.__class__, name.replace("`", ""))
            setattr(self, name.replace("`", ""), field.default)
        for key, value in kwargs.items():
            setattr(self, key.replace("`", ""), value)

    def __str__(self):
        return f'{self.__class__.__name__}_{self.id}'

    def __repr__(self):
        return self.__str__()

    @property
    def field_names(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        names = []
        for name in dir(self.__class__):
            var = getattr(self.__class__, name.replace("`", ""))
            if isinstance(var, Field):
                names.append(f"`{name}`")
        return names

    @property
    def field_values(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        values = []
        for name in self.field_names:
            value = getattr(self, name.replace("`", ""))
            if isinstance(value, datetime):
                value = value.timestamp()
            if isinstance(value, Model):
                value = value.id
            if isinstance(value, str):
                value = value.replace("'", "''")
            values.append(f"'{value}'")
        return values

    def insert(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cursor = db.get_cursor()
        field_names_sql = ", ".join(self.field_names)
        field_values_sql = ", ".join(self.field_values)

        sql = f"insert into `{self.table_name}`({ field_names_sql}) values({field_values_sql})"
        db.execute_sql(cursor, sql)
        db.db_commit()

        sql = f"select id from `{self.table_name}` order by id desc;"
        db.execute_sql(cursor, sql)
        self.id = cursor.fetchone()[0]

    def update(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cursor = db.get_cursor()

        name_value = []

        for name, value in zip(self.field_names, self.field_values):
            name_value.append(f"{name}={value}")
        name_value_sql = ", ".join(name_value)

        sql = f"update `{self.table_name}` set {name_value_sql} where id = {self.id}"
        db.execute_sql(cursor, sql)
        db.db_commit()

    def save(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        if self.id:
            self.update()
        else:
            self.insert()
        return self

    def delete(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cursor = db.get_cursor()
        sql = f"delete from `{self.table_name}` where id = {self.id}"
        db.execute_sql(cursor, sql)
        db.db_commit()

    @classmethod
    def try_create_table(cls):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        table_name = cls.__name__.lower()
        cursor = db.get_cursor()
        sql = f"select * from sqlite_master where type='table' AND name='{table_name}';"
        db.execute_sql(cursor, sql)
        if not cursor.fetchall():
            sql = f"drop table if exists `{table_name}`;"
            db.execute_sql(cursor, sql)

            fields_sql = ""
            for name in dir(cls):
                var = getattr(cls, name.replace("`", ""))
                if isinstance(var, Field):
                    field = var
                    field_sql = field.field_sql(name)
                    fields_sql += ", " + field_sql
            sql = f'create table `{table_name}` ("id" integer not null primary key {fields_sql});'
            db.execute_sql(cursor, sql)

            db.db_commit()

    @classmethod
    def query(cls):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        query = Query(cls)
        return query

    @classmethod
    def get(cls, **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        query = Query(cls)
        return query.filter(**kwargs).first()


class Query:
class SomeClass:
    def some_method(self):
        """Do x and return foo."""

    def __init__(self, model_class):
        model_class.try_create_table()
        self.model_class = model_class
        self.table_name = self.model_class.__name__
        self.where_sql = "1=1"

    def __str__(self):
        return f"{self.__class__.__name__}_{self.table_name,}_{self.query_sql}"

    def __repr__(self):
        return self.__str__()

    @property
    def field_names(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        names = []
        for name in dir(self.model_class):
            var = getattr(self.model_class, name.replace("`", ""))
            if isinstance(var, Field):
                names.append(f"`{name}`")
        return names

    @property
    def query_sql(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        sql = f"select * from `{self.table_name}` where {self.where_sql};"
        return sql

    def filter(self, operator="=", **kwargs):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        where_sql = self.where_sql
        for name, value in kwargs.items():
            if f"`{name}`" in self.field_names + ["`id`"]:
                if isinstance(value, Model):
                    value = value.id
                if isinstance(value, str):
                    value = value.replace("'", "''")
                where_sql += f" and `{name}` {operator} '{value}'"
        query = self.__class__(self.model_class)
        query.where_sql = where_sql
        return query

    def _r2ob(self, item):
        value = ''
        inst_id = item[0]
        obj = self.model_class(inst_id=inst_id)
        for i in range(1, len(item)):
            name = self.field_names[i - 1]
            field = getattr(self.model_class, name.replace("`", ""))
            if not field.is_foreign_key:
                value = field.to_python(item[i])
            if field.is_foreign_key:
                if field.field_type == "foreignkey":
                    fid = item[i]
                    value = field.model_class.get(id=fid)
            setattr(obj, name.replace("`", ""), value)
        return obj

    def all(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cursor = db.get_cursor()
        sql = self.query_sql
        db.execute_sql(cursor, sql)
        rows = cursor.fetchall()
        obs = []
        for item in rows:
            ob = self._r2ob(item)

            obs.append(ob)
        return obs

    def first(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cursor = db.get_cursor()
        sql = self.query_sql
        db.execute_sql(cursor, sql)
        rows = cursor.fetchall()
        if rows:

            r = rows[0]

            ob = self._r2ob(r)

            return ob
        else:
            return None

    def delete(self):
class SomeClass:
    def some_method(self):
        """Do x and return foo."""
        cursor = db.get_cursor()
        sql = f"delete from `{self.table_name}` where {self.where_sql}"
        db.execute_sql(cursor, sql)
        db.db_commit()


1			from datetime import datetime
			0 ignored issues – show Coding Style introduced 2018-08-19 20:26 UTC by Report Bug Copy Issue Report This module should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
2
3			from weekorm import db
4
5
6			class Field:
			0 ignored issues – show Coding Style introduced 2018-08-19 20:26 UTC by Report Bug Copy Issue Report This class should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... Unused Code introduced 2018-08-19 20:26 UTC by Report Bug Copy Issue Report The variable `__class__` seems to be unused. Loading history...
7			field_type = ''
8			default = ''
9			is_foreign_key = False
10			unique = False
11			not_null = False
12			python_type = str
13
14			def field_sql(self, field_name):
			0 ignored issues – show Coding Style introduced 2018-08-19 20:26 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
15			field_sql = f'"{field_name}" {self.field_type}'
16			if self.unique:
17			field_sql += ' UNIQUE'
18			if self.not_null:
19			field_sql += ' NOT NULL'
20			return field_sql
21
22			def to_python(self, value):
			0 ignored issues – show Coding Style introduced 2018-08-19 20:26 UTC by Report Bug Copy Issue Report This method should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history...
23			if self.python_type == datetime:
24			value = datetime.fromtimestamp(value)
25			return value
26			return self.python_type(value)
27
28
29			class CharField(Field):
			0 ignored issues – show Coding Style introduced 2018-08-19 20:26 UTC by Report Bug Copy Issue Report This class should have a docstring. The coding style of this project requires that you add a docstring to this code element. Below, you find an example for methods: class SomeClass: def some_method(self): """Do x and return foo.""" If you would like to know more about docstrings, we recommend to read PEP-257: Docstring Conventions. Loading history... Unused Code introduced 2018-08-19 20:26 UTC by Report Bug Copy Issue Report The variable `__class__` seems to be unused. Loading history...
30			def __init__(self, max_length=255, default='', unique=False):
31			self.field_type = f'varchar({max_length})'
32			self.default = default
33			self.max_length = max_length
34			self.unique = unique
35			self.python_type = str

mitrofun / weakorm

weekorm.model D last analyzed 2018-09-01 21:11 UTC

Complexity

Size/Duplication

Importance

31 Methods

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like

weekorm.model D
last analyzed 2018-09-01 21:11 UTC