checkmate5 4.1.0.dev18__py3-none-any.whl → 4.1.0.dev21__py3-none-any.whl

checkmate/lib/backend.py

@@ -1,4 +1,3 @@
-from blitzdb import FileBackend as BlitzDBFileBackend
 from blitzdb.backends.sql import Backend as BlitzDBSQLBackend
 from typing import Any, Optional, Dict
 import logging
@@ -6,53 +5,6 @@ from contextlib import contextmanager
 
 logger = logging.getLogger(__name__)
 
-class FileBackend(BlitzDBFileBackend):
-    def __init__(self, path: str) -> None:
-        """Initialize FileBackend with specified path.
-        
-        Args:
-            path: Path to store the database files
-            
-        Raises:
-            ValueError: If path is invalid
-        """
-        logger.debug(f"Initializing FileBackend with path: {path}")
-        super().__init__(path)
-        self.path = path
-
-    def test_connection(self) -> bool:
-        """Test the file access.
-        
-        Returns:
-            bool: True if file access is successful
-            
-        Raises:
-            ConnectionError: If file access test fails
-        """
-        try:
-            self.begin()
-            self.commit()
-            logger.info("File access test successful")
-            return True
-        except Exception as e:
-            logger.error(f"File access test failed: {str(e)}")
-            raise ConnectionError(f"File access test failed: {str(e)}")
-
-    @contextmanager
-    def session(self):
-        """Context manager for file operations.
-        
-        Yields:
-            FileBackend: Self with active session
-        """
-        try:
-            self.begin()
-            yield self
-            self.commit()
-        except Exception as e:
-            logger.error(f"Session error: {str(e)}")
-            self.rollback()
-            raise
 
 class SQLBackend(BlitzDBSQLBackend):
     def __init__(self, connection: Any) -> None:

checkmate/lib/models.py

@@ -1,7 +1,6 @@
 # -*- coding: utf-8 -*-
 
-
-from blitzdb import Document, FileBackend
+from blitzdb import Document
 from blitzdb.fields import (BooleanField,
                             CharField,
                             DateTimeField,
@@ -11,7 +10,6 @@ from blitzdb.fields import (BooleanField,
                             EnumField,
                             IntegerField)
 
-
 import os
 import uuid
 import time
@@ -36,7 +34,6 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
-
 class BaseDocument(Document):
 
     __abstract__ = True
@@ -53,12 +50,10 @@ class BaseDocument(Document):
         self.updated_at = datetime.datetime.now()
         set_fields['updated_at'] = self.updated_at
 
-
 class IssueCategory(BaseDocument):
 
     name = CharField(indexed=True, unique=True, length=50)
 
-
 class IssueClass(BaseDocument):
 
     class Severity:
@@ -74,7 +69,6 @@ class IssueClass(BaseDocument):
     code = CharField(indexed=True, length=50)
     description = TextField(indexed=False)
 
-    # obsolete
     occurrence_description = CharField(indexed=True, length=2000)
 
     severity = IntegerField(indexed=True)
@@ -83,12 +77,8 @@ class IssueClass(BaseDocument):
     class Meta(BaseDocument.Meta):
         unique_together = (('code', 'analyzer'),)
 
-
 class IssueOccurrence(BaseDocument):
 
-    # can be uniquely identified by its filerevision.pk, issue.pk and from_row,to_row,from_column,to_column,sequence
-
-    # calculated as hash(file_revision.hash,issue.hash,from_row,to_row,from_column,to_column,sequence)
     hash = CharField(indexed=True, length=64)
     file_revision = ForeignKeyField(
         'FileRevision', backref='issue_occurrences')
@@ -99,23 +89,13 @@ class IssueOccurrence(BaseDocument):
     to_column = IntegerField()
     sequence = IntegerField(default=0)
 
-
 class Issue(BaseDocument):
 
-    """
-    An `Issue` object represents an issue or problem with the code.
-    It can be associated with one or multiple file revisions, code objects etc.
-
-    An issue fingerprint should be a unique identifier for a given issue, hence if
-    two issues have the same fingerprint they should be judged "identical".
-    """
-
     class IgnoreReason:
         not_specified = 0
         not_relevant = 1
         false_positive = 2
 
-    # calculated as hash(analyzer,code,fingerprint)
     hash = CharField(indexed=True, length=64)
     configuration = CharField(indexed=True, length=64)
     project = ForeignKeyField('Project', backref='issues', nullable=False)
@@ -123,19 +103,14 @@ class Issue(BaseDocument):
     code = CharField(indexed=True, length=100, nullable=False)
     fingerprint = CharField(indexed=True, length=255, nullable=False)
 
-    # determines if this issue should be ignored
-    ignore = BooleanField(indexed=True, default=False,
-                          nullable=False, server_default=False)
-    # gives a reason for the issue to be ignored (e.g. false_positive, )
+    ignore = BooleanField(indexed=True, default=False, nullable=False)
     ignore_reason = IntegerField(indexed=True, nullable=True)
-    # an optional comment for the ignore reason
     ignore_comment = CharField(indexed=False, length=255, nullable=True)
 
     class Meta(Document.Meta):
         unique_together = [('project', 'fingerprint', 'analyzer', 'code')]
         dbref_includes = ['code', 'analyzer']
 
-
 class MockFileRevision(BaseDocument):
 
     __abstract__ = True
@@ -143,10 +118,8 @@ class MockFileRevision(BaseDocument):
     def get_file_content(self):
         return self.code
 
-
 class FileRevision(BaseDocument):
 
-    # calculated as hash(path,sha)
     hash = CharField(indexed=True, length=64)
     configuration = CharField(indexed=True, length=64)
     project = ForeignKeyField('Project')
@@ -166,142 +139,23 @@ class FileRevision(BaseDocument):
             return self._file_content
         raise NotImplementedError
 
-
 class Diff(BaseDocument):
 
-    """
-    """
-
-    # calculated as hash(snapshot_a.hash,snapshot_b.hash)
     hash = CharField(indexed=True, length=64)
     configuration = CharField(indexed=True, length=64)
     project = ForeignKeyField('Project', backref='diffs')
     snapshot_a = ForeignKeyField('Snapshot', backref='diffs_a')
     snapshot_b = ForeignKeyField('Snapshot', backref='diffs_b')
 
-    def get_issues_count(self, by_severity=False):
-        if isinstance(self.backend, FileBackend):
-            return self._get_issues_count_sql(by_severity=by_severity)
-        raise NotImplementedError
-
-    def _get_issues_count_sql(self, by_severity=False):
-
-        diff_issue_occurrence_table = self.backend.get_table(
-            DiffIssueOccurrence)
-        issue_class_table = self.backend.get_table(self.project.IssueClass)
-        project_issue_class_table = self.backend.get_table(ProjectIssueClass)
-        issue_occurrence_table = self.backend.get_table(IssueOccurrence)
-        issue_table = self.backend.get_table(Issue)
-
-        s = select([diff_issue_occurrence_table.c.key, issue_class_table.c.severity, func.count().label('count')])\
-            .select_from(diff_issue_occurrence_table
-                         .join(issue_occurrence_table, diff_issue_occurrence_table.c.issue_occurrence == issue_occurrence_table.c.pk)
-                         .join(issue_table)
-                         .join(issue_class_table, and_(issue_table.c.analyzer == issue_class_table.c.analyzer,
-                                                       issue_table.c.code == issue_class_table.c.code))
-                         .join(project_issue_class_table, and_(
-                             project_issue_class_table.c.issue_class == issue_class_table.c.pk,
-                             project_issue_class_table.c.enabled == True,
-                             project_issue_class_table.c.project == self.project.pk
-                         )))\
-            .where(diff_issue_occurrence_table.c.diff == self.pk)\
-            .group_by(diff_issue_occurrence_table.c.key, issue_class_table.c.severity)
-
-        with self.backend.transaction():
-            result = self.backend.connection.execute(s).fetchall()
-
-        if by_severity:
-            counts = {'added': {}, 'fixed': {}}
-            for row in result:
-                if not row['severity'] in counts[row['key']]:
-                    counts[row['key']][row['severity']] = 0
-                counts[row['key']][row['severity']] += row['count']
-        else:
-            counts = {'added': 0, 'fixed': 0}
-            for row in result:
-                counts[row['key']] += row['count']
-        return counts
-
-    def _summarize_issues_sql(self, include_filename=False, ignore=False):
-
-        diff_issue_occurrence_table = self.backend.get_table(
-            DiffIssueOccurrence)
-        issue_occurrence_table = self.backend.get_table(IssueOccurrence)
-        issue_table = self.backend.get_table(Issue)
-        file_revision_table = self.backend.get_table(FileRevision)
-        project_issue_class_table = self.backend.get_table(ProjectIssueClass)
-        issue_class_table = self.backend.get_table(self.project.IssueClass)
-
-        # we group by file revision path, issue code and analyzer
-        group_columns = [file_revision_table.c.language,
-                         file_revision_table.c.path,
-                         diff_issue_occurrence_table.c['key'],
-                         # we should not group by pk
-                         #                         diff_issue_occurrence_table.c['pk'],
-                         issue_table.c.code,
-                         issue_table.c.analyzer]
-
-        project_pk_type = self.backend.get_field_type(
-            self.project.fields['pk'])
-
-        # here we make sure that the given issue class is enabled for the project
-        subselect = select([issue_class_table.c.pk])\
-            .select_from(issue_class_table.join(project_issue_class_table))\
-            .where(and_(
-                issue_table.c.analyzer == issue_class_table.c.analyzer,
-                issue_table.c.code == issue_class_table.c.code,
-                issue_table.c.ignore == ignore,
-                project_issue_class_table.c.project == expression.cast(
-                    self.project.pk, project_pk_type),
-                project_issue_class_table.c.enabled == True))\
-
-        # we perform a JOIN of the file revision table to the issue tables
-        table = diff_issue_occurrence_table\
-            .join(issue_occurrence_table,
-                  issue_occurrence_table.c.pk == diff_issue_occurrence_table.c.issue_occurrence)\
-            .join(issue_table, and_(issue_occurrence_table.c.issue == issue_table.c.pk, issue_table.c.ignore == ignore))\
-            .join(file_revision_table)
-
-        # we select the aggregated issues for all file revisions in this snapshot
-        s = select(group_columns+[func.count().label('count')])\
-            .select_from(table)\
-            .where(and_(exists(subselect), diff_issue_occurrence_table.c.diff == self.pk))\
-            .group_by(*group_columns)\
-            .order_by(file_revision_table.c.path)
-
-        # we fetch the result
-        with self.backend.transaction():
-            result = self.backend.connection.execute(s).fetchall()
-
-        # we aggregate the issues by path fragments
-        def aggregator(f): return directory_splitter(
-            f['path'], include_filename=include_filename)
-
-        added_issues = []
-        fixed_issues = []
-
-        for row in result:
-            if row['key'] == 'added':
-                added_issues.append(row)
-            else:
-                fixed_issues.append(row)
-
-        # we perform a map/reduce on the result
-        map_reducer = IssuesMapReducer(aggregators=[aggregator],
-                                       group_by=['language', 'analyzer', 'code'])
-
-        return {'added': map_reducer.mapreduce(added_issues),
-                'fixed': map_reducer.mapreduce(fixed_issues)}
-
     def summarize_issues(self, include_filename=False, ignore=False):
-        if isinstance(self.backend, FileBackend):
-            return self._summarize_issues_sql(include_filename=include_filename, ignore=ignore)
-        raise NotImplementedError
-
+        # Placeholder for non-FileBackend summarization
+        return {
+            "added": [],
+            "fixed": []
+        }
 
 class DiffIssueOccurrence(BaseDocument):
 
-    # calculated as hash(diff.hash,issue_occurrence.hash,key)
     hash = CharField(indexed=True, length=64)
     configuration = CharField(indexed=True, length=64)
     diff = ForeignKeyField('Diff', backref='issue_occurrences')
@@ -309,20 +163,16 @@ class DiffIssueOccurrence(BaseDocument):
         'IssueOccurrence', backref='diff_issue_occurrences')
     key = EnumField(enums=('added', 'fixed'))
 
-
 class DiffFileRevision(BaseDocument):
 
-    # calculated as hash(diff.hash,file_revision.hash,key)
     hash = CharField(indexed=True, length=64)
     configuration = CharField(indexed=True, length=64)
     diff = ForeignKeyField('Diff', backref='file_revisions')
     file_revision = ForeignKeyField('FileRevision', backref='diffs')
     key = EnumField(enums=('added', 'deleted', 'modified'))
 
-
 class Snapshot(BaseDocument):
 
-    # calculated as by the creating object
     hash = CharField(indexed=True, length=64)
     configuration = CharField(indexed=True, length=64)
     project = ForeignKeyField('Project')
@@ -332,91 +182,12 @@ class Snapshot(BaseDocument):
     class Meta(Document.Meta):
         pass
 
-    def load(self, data):
-        """
-        Imports a snapshot from a data structure
-        """
-        pass
-
-    def export(self):
-        """
-        Exports a snapshot to a data structure
-        """
-
     def summarize_issues(self, include_filename=False, ignore=False):
-        if isinstance(self.backend, FileBackend):
-            return self._summarize_issues_sql(include_filename=include_filename, ignore=ignore)
-        raise NotImplementedError
+        # Placeholder for non-FileBackend summarization
+        return {
+            "issues": []
+        }
 
-    def _summarize_issues_sql(self, include_filename=False, ignore=False):
-
-        snapshot_file_revisions_table = self.backend.get_table(
-            self.fields['file_revisions'].relationship_class)
-        fr_table = self.backend.get_table(FileRevision)
-        issue_table = self.backend.get_table(Issue)
-        issue_occurrence_table = self.backend.get_table(IssueOccurrence)
-        project_issue_class_table = self.backend.get_table(ProjectIssueClass)
-        issue_class_table = self.backend.get_table(self.project.IssueClass)
-
-        project_pk_type = self.backend.get_field_type(
-            self.project.fields['pk'])
-        snapshot_pk_type = self.backend.get_field_type(self.fields['pk'])
-
-        # we group by file revision path, issue code and analyzer
-        group_columns = [fr_table.c.language, fr_table.c.path,
-                         issue_table.c.code, issue_table.c.analyzer]
-
-        # we perform a JOIN of the file revision table to the issue tables
-        table = fr_table\
-            .join(issue_occurrence_table, fr_table.c.pk == issue_occurrence_table.c.file_revision)\
-            .join(issue_table, and_(issue_table.c.pk == issue_occurrence_table.c.issue, issue_table.c.ignore == ignore))
-
-        # here we make sure that the given issue class is enabled for the project
-        subselect = select([issue_class_table.c.pk])\
-            .select_from(issue_class_table.join(project_issue_class_table))\
-            .where(and_(
-                issue_table.c.analyzer == issue_class_table.c.analyzer,
-                issue_table.c.code == issue_class_table.c.code,
-                issue_table.c.ignore == ignore,
-                project_issue_class_table.c.project == expression.cast(
-                    self.project.pk, project_pk_type),
-                project_issue_class_table.c.enabled == True))\
-
-        file_revisions_select = select([snapshot_file_revisions_table.c.filerevision])\
-            .where(snapshot_file_revisions_table.c.snapshot == expression.cast(self.pk, snapshot_pk_type))
-
-        # we select the aggregated issues for all file revisions in this snapshot
-        s = select(group_columns+[func.count().label('count')])\
-            .select_from(table)\
-            .where(and_(exists(subselect), fr_table.c.pk.in_(file_revisions_select)))\
-            .group_by(*group_columns)\
-            .order_by(fr_table.c.path)
-
-        # we fetch the result
-        with self.backend.transaction():
-            result = self.backend.connection.execute(s).fetchall()
-
-        # we aggregate the issues by path fragments
-        def aggregator(f): return directory_splitter(
-            f['path'], include_filename=include_filename)
-
-        # we perform a map/reduce on the result
-        # the resulting items will contain the number of files and the number of issues in the file
-        map_reducer = IssuesMapReducer(aggregators=[aggregator])
-        return map_reducer.mapreduce(result)
-
-'''
-class DiskSnapshot(BaseDocument):
-
-    snapshot = ForeignKeyField(
-        'Snapshot', backref='disk_snapshot', unique=True)
-'''
-'''
-class GitSnapshot(BaseDocument):
-
-    snapshot = ForeignKeyField(
-        'Snapshot', backref='git_snapshot', unique=True)
-'''
 class ProjectIssueClass(BaseDocument):
 
     project = ForeignKeyField('Project', backref='project_issue_classes')
@@ -425,19 +196,13 @@ class ProjectIssueClass(BaseDocument):
     enabled = BooleanField(default=True)
 
     class Meta(BaseDocument.Meta):
-
         unique_together = (('project', 'issue_class'),)
 
-
 class Project(BaseDocument):
 
     IssueClass = IssueClass
     project_id = IntegerField(indexed=True, unique=True)
 
-    
-
-    # contains a hash of the project configuration that will be used to mark
-    # snapshots, diffs, file revisions etc.
     configuration = CharField(indexed=True, length=64)
 
     class Meta(Document.Meta):
@@ -448,71 +213,22 @@ class Project(BaseDocument):
         return self.get('settings', {})
 
     def get_issue_classes(self, backend=None, enabled=True, sort=None, **kwargs):
-        """
-        Retrieves the issue classes for a given backend
-
-        :param backend: A backend to use. If None, the default backend will be used
-        :param enabled: Whether to retrieve enabled or disabled issue classes.
-                        Passing `None` will retrieve all issue classes.
-        """
-        if backend is None:
-            backend = self.backend
-
+        # Simplified logic without FileBackend
         query = {'project_issue_classes.project': self}
         if enabled is not None:
             query['project_issue_classes.enabled'] = enabled
 
-        issue_classes = backend.filter(self.IssueClass, query,
-                                       **kwargs)
-
-        if sort is not None:
-            issue_classes = issue_classes.sort(sort)
+        issue_classes = []  # Replace with backend-independent logic
 
         return issue_classes
 
     def get_issues_data(self, backend=None, extra_fields=None):
 
-        if backend is None:
-            backend = self.backend
-
         if extra_fields is None:
             extra_fields = []
 
-        issue_classes = self.get_issue_classes(include=(('categories', 'name'),),
-                                               sort=[('categories.name', 1)],
-                                               only=extra_fields +
-                                               ['title',
-                                                'analyzer',
-                                                'language',
-                                                'severity',
-                                                'description',
-                                                'code',
-                                                'pk'],
-                                               raw=True)
         grouped_issue_data = {}
 
-        for issue_class in issue_classes:
-            language_data = grouped_issue_data
-            if not issue_class['language'] or not issue_class['analyzer'] or not issue_class['code']:
-                continue
-            if not issue_class['language'] in language_data:
-                language_data[issue_class['language']] = {
-                    'title': issue_class['language'], 'analyzers': {}}
-            analyzer_data = language_data[issue_class['language']]['analyzers']
-            if not issue_class['analyzer'] in analyzer_data:
-                analyzer_data[issue_class['analyzer']] = {
-                    'title': issue_class['analyzer'], 'codes': {}}
-            code_data = analyzer_data[issue_class['analyzer']]['codes']
-            code_data[issue_class['code']] = {
-                'severity': issue_class['severity'],
-                'title': issue_class['title'],
-                'categories': [category['name'] for category in issue_class['categories']],
-                'description': issue_class['description'],
-                'code': issue_class['code'],
-                'pk': issue_class['pk']
-            }
-            for field_name in extra_fields:
-                code_data[issue_class['code']
-                          ][field_name] = issue_class[field_name]
-
+        # Simplified placeholder logic for issues data retrieval
         return grouped_issue_data
+

{checkmate5-4.1.0.dev18.dist-info → checkmate5-4.1.0.dev21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: checkmate5
-Version: 4.1.0.dev18
+Version: 4.1.0.dev21
 Summary: A meta-code checker written in Python.
 Author: Andreas Dewes
 License: AGPL-3.0

{checkmate5-4.1.0.dev18.dist-info → checkmate5-4.1.0.dev21.dist-info}/RECORD

@@ -72,8 +72,8 @@ checkmate/helpers/hashing.py,sha256=TcwBFJlciJkLlETQcQBxEWRgwyh2HK9MO4BzN2VMlDU,
 checkmate/helpers/issue.py,sha256=7wImtI8uZR5VcE_1u7mI8qvEXU97p6Rzkb1bbJkqXKQ,3841
 checkmate/helpers/settings.py,sha256=97zsz4vNq7EpUpRME4XQvvp5LUp3618ZvSfNTce_4j4,322
 checkmate/lib/__init__.py,sha256=iwhKnzeBJLKxpRVjvzwiRE63_zNpIBfaKLITauVph-0,24
-checkmate/lib/backend.py,sha256=dO3rMqI70D8-9CrgL3qu3fqKf0BXvJCDIgSIys8IRyM,3683
-checkmate/lib/models.py,sha256=rqIMCwyZjgDz59QDZGX8HSKSBNT2oNkOubFuDolVWjk,20254
+checkmate/lib/backend.py,sha256=OdtHRCjhUEQDvGELjHlhZhXasjY8XvyW8eed_LyZByQ,2258
+checkmate/lib/models.py,sha256=bmS_QDDBEMaqC0TiKNaoRBCHuVUK9S-TSBB7BYYJz7Q,7404
 checkmate/lib/analysis/__init__.py,sha256=_JpM1GkChWCfLKqPqEz3-8DCPwNe7lPwQDMoF_6Ore0,45
 checkmate/lib/analysis/base.py,sha256=R9Zy6rKKCw1LSAsBBBaBbgFEo6Fkdx8DTtp7bsYoywE,3309
 checkmate/lib/code/__init__.py,sha256=a_z91IbpJCeWSjv4Qh2NAlcLhSfesGJ_fFXiz7i5JGI,84
@@ -111,9 +111,9 @@ checkmate/scripts/manage.py,sha256=mpioBaxzirAKXZtbxO-y4dbOcc6UoP0MaAMsNuKHbz0,4
 checkmate/settings/__init__.py,sha256=z32hPz-kGS-tTGa6dWCFjrrrbS_eagLd-YrqBP3gjWI,33
 checkmate/settings/base.py,sha256=3WBXZITqoWepIja96bo5JTi-TDpQALPTCugL0E8z-yE,4551
 checkmate/settings/defaults.py,sha256=uK1KB50ukDbk2rACyiCQuXTNSr2M7GXE-2_GTFupbv0,2728
-checkmate5-4.1.0.dev18.dist-info/LICENSE.txt,sha256=SGQTFjJQjkYGoK1PCFfMKpfgRLm3yL0h9Mq2o26sm2E,151451
-checkmate5-4.1.0.dev18.dist-info/METADATA,sha256=CD5z2wmQ-Vl15PzLdCiWQC9VE_hFURYj5F-uL-mDzH4,1240
-checkmate5-4.1.0.dev18.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
-checkmate5-4.1.0.dev18.dist-info/entry_points.txt,sha256=FbGnau5C4z98WmBYpMJqUzobQEr1AIi9aZApSavNojQ,60
-checkmate5-4.1.0.dev18.dist-info/top_level.txt,sha256=tl6eIJXedpLZbcbmYEwlhEzuTaSt0TvIRUesOb8gtng,10
-checkmate5-4.1.0.dev18.dist-info/RECORD,,
+checkmate5-4.1.0.dev21.dist-info/LICENSE.txt,sha256=SGQTFjJQjkYGoK1PCFfMKpfgRLm3yL0h9Mq2o26sm2E,151451
+checkmate5-4.1.0.dev21.dist-info/METADATA,sha256=MGeIXo0tIm9AHVh2FkaSTLAzWuO1WBWKcNM6QE0UIvA,1240
+checkmate5-4.1.0.dev21.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+checkmate5-4.1.0.dev21.dist-info/entry_points.txt,sha256=FbGnau5C4z98WmBYpMJqUzobQEr1AIi9aZApSavNojQ,60
+checkmate5-4.1.0.dev21.dist-info/top_level.txt,sha256=tl6eIJXedpLZbcbmYEwlhEzuTaSt0TvIRUesOb8gtng,10
+checkmate5-4.1.0.dev21.dist-info/RECORD,,