minchoc 0.0.8__py3-none-any.whl → 0.1.0__py3-none-any.whl

minchoc/__init__.py

@@ -0,0 +1,7 @@
+"""minchoc package."""
+from __future__ import annotations
+
+import django_stubs_ext
+
+django_stubs_ext.monkeypatch()
+__version__ = '0.1.0'

minchoc/admin.py

@@ -1,3 +1,6 @@
+"""Django admin model registrations."""
+from __future__ import annotations
+
 from django.contrib import admin
 
 from .models import Author, Company, NugetUser, Package

minchoc/apps.py

@@ -1,6 +1,10 @@
+"""App configuration."""
+from __future__ import annotations
+
 from django.apps import AppConfig
 
 
 class MainConfig(AppConfig):
+    """Configuration for the minchoc app."""
     default_auto_field = 'django.db.models.BigAutoField'
     name = 'minchoc'

minchoc/constants.py

@@ -1,6 +1,9 @@
+"""Constants."""
+from __future__ import annotations
+
 __all__ = ('FEED_XML_POST', 'FEED_XML_PRE')
 
-FEED_XML_PRE = '''<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+FEED_XML_PRE = """<?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <feed xml:base="%(BASEURL)s/api/v1/"
     xmlns="http://www.w3.org/2005/Atom"
     xmlns:d="http://schemas.microsoft.com/ado/2007/08/dataservices"
@@ -8,5 +11,15 @@ FEED_XML_PRE = '''<?xml version="1.0" encoding="utf-8" standalone="yes"?>
     <id>%(BASEURL)s/api/v1/Packages</id>
     <title type="text">Packages</title>
     <updated>%(UPDATED)s</updated>
-    <link rel="self" title="Packages" href="Packages" />'''
+    <link rel="self" title="Packages" href="Packages" />"""
+"""
+Feed XML preamble.
+
+:meta hide-value:
+"""
 FEED_XML_POST = '</feed>'
+"""
+Feed XML file suffix.
+
+:meta hide-value:
+"""

minchoc/filterlex.py

@@ -1,3 +1,7 @@
+"""Lexer."""
+# ruff: noqa: D300,D400,N816
+from __future__ import annotations
+
 from typing import Any
 
 from ply import lex
@@ -5,14 +9,21 @@ from ply import lex
 __all__ = ('tokens',)
 
 states = (('string', 'exclusive'),)
-tokens = ('AND', 'EQ', 'ISLATESTVERSION', 'LPAREN', 'RPAREN', 'STRING', 'TOLOWER_ID')
+tokens = ('AND', 'COMMA', 'EQ', 'FIELD', 'ISLATESTVERSION', 'LPAREN', 'NE', 'NULL', 'OR', 'RPAREN',
+          'STRING', 'SUBSTRINGOF', 'TOLOWER')
 
 t_AND = r'and'
+t_COMMA = r','
 t_EQ = r'eq'
+t_FIELD = r'Description|Id|Tags'
 t_ISLATESTVERSION = r'IsLatestVersion'
-t_TOLOWER_ID = r'tolower\(Id\)'
 t_LPAREN = r'\('
+t_NE = r'ne'
+t_NULL = r'null'
+t_OR = r'or'
 t_RPAREN = r'\)'
+t_SUBSTRINGOF = r'substringof'
+t_TOLOWER = r'tolower'
 
 t_ignore = ' '
 t_string_ignore = ' '
@@ -36,14 +47,14 @@ def t_string_escapedquote(_t: lex.LexToken) -> None:
 def t_string_quote(t: lex.LexToken) -> lex.LexToken:
     r"'"
     t.value = t.lexer.lexdata[t.lexer.code_start:t.lexer.lexpos - 1]
-    t.type = "STRING"
+    t.type = 'STRING'
     t.lexer.lineno += t.value.count('\n')
     t.lexer.begin('INITIAL')
     return t
 
 
 def t_string_error(t: lex.LexToken) -> None:
-    # print("illegal character '%s'" % t.value[0])
+    # print("illegal character '%s'" % t.value[0])  # noqa: ERA001
     t.lexer.skip(1)
 
 

minchoc/filteryacc.py

@@ -1,56 +1,128 @@
-from typing import Any, cast
+"""Parser."""
+# ruff: noqa: D205,D208,D209,D400,D403
+from __future__ import annotations
 
-from ply import yacc
-from ply.lex import LexToken
+from typing import TYPE_CHECKING, Any, Literal, cast
 
+from django.db.models import Q
 from minchoc.filterlex import tokens  # noqa: F401
+from ply import yacc
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from ply.lex import LexToken
+
+__all__ = ('FIELD_MAPPING', 'parser')
+
+FIELD_MAPPING = {'Description': 'description', 'Id': 'nuget_id', 'Tags': 'tags__name'}
+
+
+def setup_p0(p: yacc.YaccProduction) -> None:
+    if not isinstance(p[0], Q):  # pragma no cover
+        p[0] = Q()
+
+
+def p_expression_expr(p: yacc.YaccProduction) -> None:
+    """expression : LPAREN expression RPAREN"""
+    setup_p0(p)
+    p[0] = p[2]
+
+
+def p_substringof(p: yacc.YaccProduction) -> None:
+    """substringof : SUBSTRINGOF LPAREN STRING COMMA expression RPAREN"""
+    setup_p0(p)
+    a: str
+    b: Q
+    _, __, ___, a, ____, b, _____ = p
+    db_field = cast('Sequence[Any]', b.children[0])[0]
+    prefix = ''
+    if '__iexact' in db_field:
+        prefix = 'i'
+        db_field = db_field.replace('__iexact', '')
+    p[0] &= Q(**{f'{db_field}__{prefix}contains': a})
+
+
+def p_tolower(p: yacc.YaccProduction) -> None:
+    """tolower : TOLOWER LPAREN FIELD RPAREN"""
+    setup_p0(p)
+    field: Literal['Description', 'Id', 'Tags']
+    _, __, ___, field, ____ = p
+    p[0] &= Q(**{f'{FIELD_MAPPING[field]}__iexact': None})
+
+
+def p_expression_field(p: yacc.YaccProduction) -> None:
+    """expression : FIELD"""
+    setup_p0(p)
+    field: Literal['Description', 'Id', 'Tags']
+    _, field = p
+    p[0] &= Q(**{FIELD_MAPPING[field]: None})
+
+
+class InvalidTypeForEq(Exception):
+    def __init__(self) -> None:
+        super().__init__('Only numbers and strings can be used with eq.')
+
+
+def p_expression_op(p: yacc.YaccProduction) -> None:
+    """expression : expression OR expression
+                  | expression AND expression
+                  | expression NE expression
+                  | expression EQ expression"""  # noqa: DOC501
+    setup_p0(p)
+    a: Q
+    b: Q | str
+    op: Literal['and', 'eq', 'ne', 'or']
+    _, a, op, b = p
+    if op == 'and':
+        assert isinstance(b, Q)
+        p[0] &= a & b
+    elif op == 'or':
+        assert isinstance(b, Q)
+        p[0] &= a | b
+    else:
+        db_field: str = cast('Sequence[Any]', a.children[0])[0]
+        if b == 'null' or (cast('Sequence[Any]', b.children[0])[0]
+                           if isinstance(b, Q) else None) == 'rhs__isnull':
+            p[0] &= Q(**{f'{db_field}__isnull': op != 'ne'})
+        else:  # eq
+            if not isinstance(b, int | str):
+                raise InvalidTypeForEq
+            p[0] &= Q(**{db_field: b})
+
 
-__all__ = ('parser',)
+def p_expression_str(p: yacc.YaccProduction) -> None:
+    """expression : STRING"""
+    setup_p0(p)
+    s: str
+    _, s = p
+    p[0] = s
 
 
-def dict_if_not_dict(p: yacc.YaccProduction, index: int) -> dict[Any, Any]:
-    try:
-        if not isinstance(p[index], dict):
-            return {}
-        return cast(dict[Any, Any], p[index])
-    except IndexError:
-        return {}
+class GenericSyntaxError(SyntaxError):
+    def __init__(self, index: int, token: str) -> None:
+        super().__init__(f'Syntax error (index: {index}, token: "{token}")')
 
 
 def p_expression(p: yacc.YaccProduction) -> None:
-    """
-    expression : expression AND expression
-               | LPAREN expression RPAREN
-    """
-    p[0] = {
-        **dict_if_not_dict(p, 0),
-        **dict_if_not_dict(p, 1),
-        **dict_if_not_dict(p, 2),
-        **dict_if_not_dict(p, 3)
-    }
-
-
-def p_islatestversion(p: yacc.YaccProduction) -> None:
-    """expression : ISLATESTVERSION"""
-    p[0] = {
-        **dict_if_not_dict(p, 0),
-        **dict_if_not_dict(p, 1),
-        **dict_if_not_dict(p, 2), 'is_latest_version': True
-    }
-
-
-def p_tolower_id_eq_package(p: yacc.YaccProduction) -> None:
-    """expression : TOLOWER_ID EQ STRING"""
-    p[0] = {
-        **dict_if_not_dict(p, 0),
-        **dict_if_not_dict(p, 1),
-        **dict_if_not_dict(p, 2), 'nuget_id__iexact': p[3]
-    }
+    """expression : NULL
+                  | substringof
+                  | tolower
+                  | ISLATESTVERSION"""
+    setup_p0(p)
+    expr: Any
+    _, expr = p
+    if expr == 'IsLatestVersion':
+        p[0] &= Q(is_latest_version=True)
+    elif expr == 'null':
+        p[0] &= Q(rhs__isnull=True)
+    else:
+        p[0] &= expr
 
 
 def p_error(p: LexToken) -> None:
-    raise SyntaxError('Syntax error in input')
+    raise GenericSyntaxError(p.lexer.lexpos, p.value)
 
 
-#: An extremely basic parser for parsing ``$filter`` strings.
 parser = yacc.yacc(debug=False)
+"""An extremely basic parser for parsing ``$filter`` strings. Returns a ``Q`` instance."""

minchoc/migrations/0002_alter_company_options_alter_package_unique_together_and_more.py

@@ -30,5 +30,5 @@ class Migration(migrations.Migration):
             model_name='package',
             name='version_download_count',
         ),
-        migrations.DeleteModel(name='PackageVersionDownloadCount',),
+        migrations.DeleteModel(name='PackageVersionDownloadCount'),
     ]

minchoc/models.py

@@ -1,56 +1,63 @@
-from typing import Any, cast
+"""Model definitions."""
+# ruff: noqa: D106, DJ001
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
 import uuid
 
 from django.conf import settings
-from django.contrib.auth.models import AbstractUser
 from django.db import models
 from django.db.models.signals import post_save
-from django.http import HttpRequest
-import django_stubs_ext
+from django_stubs_ext.db.models import TypedModelMeta
+from typing_extensions import override
 
-django_stubs_ext.monkeypatch()
+if TYPE_CHECKING:
+    from django.contrib.auth.models import AbstractUser
+    from django.http import HttpRequest
 
 __all__ = ('Author', 'Company', 'NugetUser', 'Package')
 
 
 class Company(models.Model):
     """Company associated to NuGet packages."""
-    class Meta:
+    name = models.CharField(max_length=255, unique=True)
+
+    class Meta(TypedModelMeta):
         verbose_name = 'company'
         verbose_name_plural = 'companies'
 
-    name = models.CharField(max_length=255, unique=True)
-
+    @override
     def __str__(self) -> str:
         return self.name
 
 
 class NugetUser(models.Model):
     """An owner of a NuGet spec."""
-    base = models.OneToOneField(settings.AUTH_USER_MODEL,
-                                on_delete=models.CASCADE)  # type: ignore[var-annotated]
+    base = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
     company = models.ForeignKey(Company, on_delete=models.CASCADE, null=True)
     token = models.UUIDField()
 
+    @override
+    def __str__(self) -> str:
+        return cast('str', self.base.username)
+
     @staticmethod
     def token_exists(token: str | None) -> bool:
-        """Simple method to check if a token exists."""
-        return bool(token and NugetUser.objects.filter(token=token).exists())
+        """Check if a token exists."""
+        return bool(token and NugetUser._default_manager.filter(token=token).exists())
 
     @staticmethod
     def request_has_valid_token(request: HttpRequest) -> bool:
-        """
-        Checks if the API key in the request (header ``X-NuGet-ApiKey``, case insensitive) is valid.
-        """
+        """Check if the API key in the request is valid."""
         return NugetUser.token_exists(request.headers.get('X-NuGet-ApiKey'))
 
-    def __str__(self) -> str:
-        return cast(str, self.base.username)
 
-
-def post_save_receiver(sender: AbstractUser, instance: AbstractUser, **kwargs: Any) -> None:
-    """Callback to create a ``NugetUser`` when a new user is saved."""
-    if not NugetUser.objects.filter(base=instance).exists():
+def post_save_receiver(
+        sender: AbstractUser,  # noqa: ARG001
+        instance: AbstractUser,
+        **kwargs: Any) -> None:  # noqa: ARG001
+    """Create a ``NugetUser`` when a new user is saved."""
+    if not NugetUser._default_manager.filter(base=instance).exists():
         nuget_user = NugetUser()
         nuget_user.base = instance
         nuget_user.token = uuid.uuid4()
@@ -64,6 +71,7 @@ class Author(models.Model):
     """Author of the software, not the NuGet spec."""
     name = models.CharField(max_length=255, unique=True)
 
+    @override
     def __str__(self) -> str:
         return self.name
 
@@ -72,18 +80,14 @@ class Tag(models.Model):
     """Tag associated to NuGet packages."""
     name = models.CharField(max_length=128, unique=True)
 
+    @override
     def __str__(self) -> str:
         return self.name
 
 
 class Package(models.Model):
     """An instance of a NuGet package."""
-    class Meta:
-        constraints = [
-            models.UniqueConstraint(fields=('nuget_id', 'version'), name='id_and_version_uniq')
-        ]
-
-    authors = models.ManyToManyField(Author)  # type: ignore[var-annotated]
+    authors = models.ManyToManyField(Author)
     copyright = models.TextField(null=True)
     dependencies = models.JSONField(null=True)
     description = models.TextField(null=True)
@@ -100,7 +104,7 @@ class Package(models.Model):
     nuget_id = models.CharField(max_length=128)
     project_url = models.URLField()
     published = models.DateTimeField(auto_now_add=True, blank=True)
-    references = models.JSONField(default=dict)  # type: ignore[var-annotated]
+    references = models.JSONField(default=dict)
     release_notes = models.TextField(null=True)
     require_license_acceptance = models.BooleanField(default=False)
     size = models.PositiveIntegerField()
@@ -116,5 +120,11 @@ class Package(models.Model):
     version3 = models.PositiveIntegerField(null=True)
     version_beta = models.CharField(max_length=128, null=True)
 
+    class Meta(TypedModelMeta):
+        constraints = [  # noqa: RUF012
+            models.UniqueConstraint(fields=('nuget_id', 'version'), name='id_and_version_uniq')
+        ]
+
+    @override
     def __str__(self) -> str:
         return f'{self.title} {self.version}'