class Package(models.Model): engine = models.ForeignKey(Engine, on_delete=models.CASCADE) ruleset = models.ForeignKey(Ruleset, on_delete=models.CASCADE) configuration = models.ForeignKey(Configuration, on_delete=models.CASCADE) created = models.DateTimeField(auto_now_add=True) 

Django x Svelte: Alpha

Warning: This project is in early Alpha and key features are still under active development. Please note that, for the time being, you will need to delete the automatically generated tsconfig.json and dxsvelte.py files from your project's root directory. The current behaviour is to not overwrite these files.

Milestone Release 0.0.18

• Route Parameters: You can now use your values in DxSvelte routes - they work. Use them to customise your server-side props, and build out your individual views as before.
• CSS Generation: CSS now builds successfully where included in the style tags, but be warned that PostCSS will still not work. For now the mixture of component styling & pre-built stylesheets has pushed the outstanding down the priority queue for now, but it is still on the list.
• Django Dict -> Svelte Data Passing: SSR improved and cleaned up, more refactoring.

Features

• Seamless Integration: DxSvelte integrates tightly with Django's route resolvers, allowing you to easily build SPAs with Svelte without manually connecting the dots through DRF (though you don't lose that functionality, should you need it). The whole philosophy here is that SPA functionality can and should be a 'first class citizen' in Django.
• Automatic SPA Generation: You don't have to manually configure REST endpoints or manage complex API interactions. Instead, DxSvelte automatically generates the SPA for you, based on the routes defined in your Django app.
• Efficient Rendering: DxSvelte uses Svelte's efficient rendering engine to deliver fast and responsive user experiences, without sacrificing the power and flexibility of Django. But not only that, DxSvelte also takes care of SSR (Server Side Rendering), so that the first page-load is already rendered when it arrives in the browser.
• Fast Compilation: DxSvelte uses ESBuild (a powerful JS compiler written in Rust) under the hood to give you the best possible compile times.
• Incremental Adoption: The default behaviour when it comes to navigation makes it easy to adopt the SPA incrementally. If you have an existing project you don't want to rewrite or only want for a specific portion of the site to be an SPA, then just keep going as you are; the SPA will honour any tags which lead away from the SPA by checking itself against the automatically generated routing table.

npx dxsvelte npm i 

my_project_name ├── manage.py ├── dxsvelte.py ├── package.json ├── tsconfig.json ├── my_project_name │ └── ... ├── static │ ├── index.html │ ├── ... └── ... 

# Example app called 'home_page' from django.urls import path from . import views urlpatterns = [ path('', views.index, name='$index'), path('about', views.about, name='$about'), ] 

from dxsvelte import render def index(req): # Your normal view logic goes here return render(req, data?) def about(req): return render(req) 

my_project_name ├── manage.py ├── dxsvelte.py ├── package.json ├── tsconfig.json ├── home_page │ ├── ... │ └── views │ ├── index.svelte │ └── about.svelte ├── my_project_name │ └── layout.svelte └── ... 

Your Website Name.
  

npm run compile 

urlpatterns = [ path('', views.index, name='$index'), path('about//', views.about, name='$about'), ] @csrf_exempt def about(req, company): data = { "aboutUsText": "Lorem ipsum dolor sit amet, consectetur adip...", "company": "You are viewing the page for " + company + "!" } return render(req, data) 

 {#if data?.company && data.aboutUsText} 
About {data.company}.
 {data.aboutUsText} {/if} Number Goes Up 

1. Californiann You can't beat the south and central California coast for pleasant temperatures year round. Long Beach, Los Angeles, San Diego, Santa Barbara and Santa Maria all have average daily highs no lower than the mid-60s for any month of the year. Nor does it get really hot. via

1. I am trying to use DRF to build my final college project,I have created custom user and based on that model I have created two user types (researcher and participant).

created = datetime user = ForeignKey(User) approved = False uploaded = False file = Path to S3 location (/videos/this_is_my_cool_video.mp4) youtube_id = None 

approved = True uploaded = True youtube_id = dQw4w9WgXcQ 

1. Which of these 2 method do you think I should follow and what's your reasoning? If neither, what other alternative would you suggest?
2. How should I go about uploading the video to Youtube, should I just use the regular Django server or should I use a Celery Task for this?
3. Any other suggestions you have?

• First Question: I was only able to get this to work by specifying many=True for the container_number field in the LoadSerializer, and then I had to change my JSON payload to a list of dictionaries instead of just a dictionary since it now expects more than one. Is this the right way to go about this? Is this a case of if it ain't broke don't fix it?
  • If I do not specify many=true, then I get this error when attempting to create a new Load via POST request with a JSON payload
    • Got AttributeError when attempting to get a value for field \container_number\ on serializer \ContainerSerializer`. The serializer field might be named incorrectly and not match any attribute or key on the `ManyRelatedManager` instance. Original exception text was: 'ManyRelatedManager' object has no attribute 'container_number'.```
  • And this is the error I got when sending a dictionary of items instead of a list of dictionaries:
    • "nonFieldErrors": [ "Expected a list of items but got type \"dict\"."]

class Load(models.Model): id = models.AutoField(primary_key=True) container_number = models.ManyToManyField(Container, through='ContainerLoad',through_fields=('load','container'),related_name='loads') ... class Container(models.Model): id = models.AutoField(primary_key=True) container_number = models.CharField(max_length=15) class Meta: db_table = "Container" class ContainerLoad(models.Model): load = models.ForeignKey(Load, on_delete=CASCADE) second_load = models.ForeignKey(Load,on_delete=CASCADE,related_name='second_load',null=True,blank=True) container = models.ForeignKey(Container, on_delete=CASCADE) class Meta: db_table = 'ContainerLoad' 

class LoadSerializer(WritableNestedModelSerializer): ... container_number = ContainerSerializer(read_only=False,many=True) ... class Meta: model = Load fields = '__all__' depth = 1 class ContainerSerializer(serializers.ModelSerializer): container_number = serializers.CharField() class Meta: model = Container fields = '__all__' depth = 1 class ContainerLoadSerializer(WritableNestedModelSerializer): class Meta: model = ContainerLoad fields = '__all__' depth = 1 

class LoadViews(APIView): def post(self, request): serializer = LoadSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response({"status": "success", "data": serializer.data}, status=status.HTTP_200_OK) else: return Response({"status": "Error", "data": serializer.errors}, status=status.HTTP_400_BAD_REQUEST) def get(self, request, id=None): if id: load = Load.objects.get(id=id) serializer = LoadSerializer(load) return Response({"status": "success", "data": serializer.data}, status=status.HTTP_200_OK) else: start = request.GET.get('start', '0') finish = request.GET.get('finish', '10') loads = Load.objects.all()[int(start):int(finish)] serializer = LoadSerializer(loads, many=True) return Response({"status": "success", "data": serializer.data}, status=status.HTTP_200_OK) 

• Form closes +/- 24 hours, before Tuesday ends of 16th November 2021, 2359hrs SGT (GMT+08)
• USD 55 each (excludes shipping)
• 7 caps
• 1 person per entry that doesn't warrant an invoice
• Character sculpted in clay, molded and then resin casted for MX stem
• 100% Handmade in Singapore
• Winners will be invoiced through Paypal (Justin Hoeden) and payment request is valid for 12 hours
• Unpaid entries will be re-raffled after the payment window

• USD 2.30 for Singapore addresses via SingPost (tracked)
• USD 10 for International via SingPost (tracked)
• Shipping/Tracking will be updated in PayPal under a week following the closure of this sale.

Rules:

• /api/entries/ - list all Entries
• /api/entries// - list Entries from a year
• /api/entries/// - list Entries from a year+month
• /api/entries//// - A single Entry's detail

1. Does that URL schema make sense for an API? It feels slightly unusual to have something like /api/entries/// for getting a list, and requiring three arguments to get a single item, but it also makes some sense.
2. DRF views have a single lookup_field and lookup_url_kwarg. How would I make a ListAPIView optionally accept both year and month for filtering the results? Similarly, how can I make a RetrieveAPIView require and use three fields/kwargs?

class MyModel(models.Model): my_dt_field = models.DateTimeField(null=True, blank=True) 

class DateTimeField(DateField): empty_strings_allowed = False ... 

raise exceptions.ValidationError( self.error_messages["invalid"], code="invalid", params={"value": value}, )