FilePathField is a CharField whose choices are limited to filenames in a certain directory on the file system. FilePathField instances are created in your database as varchar columns with a default maximum length of 100 characters.
FilePathField has following special arguments, of which the first is required:
FilePathField Django Syntax:
field_name = models.FilePathField(path=None, match=None, recursive=False, max_length=100, **options)
- FilePathField.path – This attribute is required. The absolute filesystem path to a directory from which this FilePathField should get its choices. Example:
"/home/images"
. - FilePathField.match – A regular expression, as a string, that FilePathField will use to filter filenames. Note that the regex will be applied to the base filename, not the full path. Example: “foo.*.txt$”, which will match a file called
foo23.txt
but notbar.txt
orfoo23.png
. - FilePathField.recursive – Either True or False. Default is False. Specifies whether all subdirectories of path should be included
- FilePathField.allow_files – Either
True
orFalse
. Default isTrue
. Specifies whether files in the specified location should be included. Either this orallow_folders
must be True. - FilePathField.allow_folders – Either
True
orFalse
. Default isFalse
. Specifies whether folders in the specified location should be included. Either this orallow_files
must beTrue
.
The only major point to consider is that the match applies to the base filename, not the full path. So this example:
FilePathField(path ="/home/images")n match = " foo. * " , recursive = True )
Example:
FilePathField(path, allow_files=True, allow_folders=True) FilePathField(path) FilePathField(match="’^.*?.py$’", path) FilePathField(match="’^.*?.py$’", path, recursive=True) FilePathField(path, allow_folders=True, match="’^.*?.py$’", recursive=True, required=False, allow_files=True)
Field options
Field options are arguments that are given to each field to apply some constraint or to give a specific characteristic to a particular field. For example, adding a null = True argument to FilePathField will allow it to store empty values for that table in a relational database. Here are the parameters and field attributes that FilePathField can use.
Field Options | Description |
---|---|
Null | If True, Django will store empty values as NULL in the database. Default is False. |
Blank | If True, the field is allowed to be blank. Default is False. |
db_column | The name of the database column to use for this field. If this isn’t given, Django will use the field’s name. |
Default | The default value for the field. This can be a value or a callable object. If callable it will be called every time a new object is created. |
help_text | Extra “help” text to be displayed with the form widget. It’s useful for documentation even if your field isn’t used on a form. |
primary_key | If True, this field is the primary key for the model. |
editable | If False, the field will not be displayed in the admin or any other ModelForm. They are also skipped during model validation. Default is True. |
error_messages | The error_messages argument lets you override the default messages that the field will raise. Pass in a dictionary with keys matching the error messages you want to override. |
help_text | Extra “help” text to be displayed with the form widget. It’s useful for documentation even if your field isn’t used on a form. |
verbose_name | A human-readable name for the field. If the verbose name isn’t given, Django will automatically create it using the field’s attribute name, converting underscores to spaces. |
validators | A list of validators to run for this field. See the validators documentation for more information. |
Unique | If True, this field must be unique throughout the table. |
To use Django FileField or FilePathField?
StackOverFlow question
I’m a bit confused about which field to use. What I need is just a Field that will hold a file (audio and/or another one for an image)
The FileField seems to be specifically for uploading and I think it is a bit of overkill for what I need, I also don’t like how it will automatically upload and rename the files to a unique filename (file_FHjgh758.txt) everytime something is uploaded.
The problem I have with the FilePathField is that it seems to require an absolute path, which would obviously be different from dev to production, I got around this by adding this to the model...
import os
class Foo(models.Model):
path = os.path.dirname(os.path.dirname(__file__))
path = os.join(path, ’media’)
audio = models.FilePathField(path=path)
I have no idea if this is safe or proper, and there aren’t many examples online or in the docs to draw from.
To be clear, I just want to have a field which I can point to a file (audio or image) somewhere in my system. What would be the best way to go about doing this?
Answer:
If you want to refer to files that are already on your filesystem rather than user uploaded files, then FilePathField
is the one that you want.
In this regard a few comments:
Don’t point to a path that is inside your app’s source tree. That is not safe.
You can use settings or environment variables to handle development vs. production paths, e.g., put a
FILE_PATH_FIELD_DIRECTORY
setting in your development/production settings files and refer to this setting from your app:from django.conf import settings class Foo(models.Model): audio = models.FilePathField(path=settings.FILE_PATH_FIELD_DIRECTORY)
Archived version
FilePathField has the following required and optional arguments:
- path: — absolute path to the directory whose contents you want transfer. This directory must exist.
- recursive: — if False (the default), only the direct contents of the path will be offered as choices. If True, the directory will be recursively downgraded and all descendants listed as variants.
- match: — regular expression pattern; only files with names matching this expression will be allowed as options.
- allow_files: — Optional. Either True or False. The default is True. Indicates whether to include files at the specified location. Either this or allow_folders must be True.
- allow_folders: — Optional. Either True or False. By default, this is False. Indicates whether to include folders in the specified location. Either this or allow_files must be True.
Syntax
field_name = forms.FilePathField ( ** options )
Django Form FilePathField Explanation
Illustration of a FilePathField using an example. Consider a project named pythonengineering
that has an application named geeks
.
Refer to the following articles to check how to create a project and an app in Django.
Enter the following code into the forms.py
file of the geeks application.
|
Add the geek app to INSTALLED_APPS
|
Now, in order to convert this form to a representation, we need a presentation and URL associated with this URL. Let’s first create a view in the views.py
of the geeks app,
|
Here we import this particular form from forms.py and instantiate it in the view so that it could be displayed in the template.
Now, to initiate your Django form, you need to create a home.html where you can create things as you see fit. Let’s create a form in home.html
.
|
Finally, the URL to map to this view in urls.py
|
Let’s start the server and check what’s on actually happened, Run
Python manage.py runserver
So geeks_field
FilePathField is created by replacing "_" with "". This field is for entering file paths from the user.
How to use FilePathField?
FilePathField is used to enter file paths in the database. You can enter files from a specific folder, and so on. So far, we’ve discussed how to implement FilePathField, but how to use it in a view to execute the logical part. To do some logic, we need to get the value entered in the field into a Python string instance.
In views.py,
|
As a select field, it only accepts selection input, otherwise validation errors will be encountered. Now let’s try to select an option from the field.
Date data can be retrieved using the appropriate query dictionary. If the method is GET, the data will be available in request.GET, and if post, then request.POST , respectively. In the above example, we have a value in temp that we can use for any purpose.
Basic Field Arguments
Basic Field Arguments — they are arguments given to each field to apply some kind of constraint or to convey a particular characteristic to a particular field. For example, adding the required = False
argument to the FilePathField will allow the user to leave it blank. Each Field constructor takes at least these arguments. Some Field classes accept additional field-specific arguments, but you should always accept the following:
Field Options | Description |
---|---|
required | By default, each Field class assumes the value is required, so to make it not required you need to set required=False |
label | The label argument lets you specify the “ human-friendly ”label for this field. This is used when the Field is displayed in a Form. |
label_suffix | The label_suffix argument lets you override the form’s label_suffix on a per-field basis. |
widget | The widget argument lets you specify a Widget class to use when rendering this Field. See Widgets for more information. |
help_text | The help_text argument lets you specify descriptive text for this Field. If you provide help_text, it will be displayed next to the Field when the Field is rendered by one of the convenience Form methods. |
error_messages | The error_messages argument lets you override the default messages that the field will raise. Pass in a dictionary with keys matching the error messages you want to override. |
validators | The validators argument lets you provide a list of validation functions for this field. |
localize | The localize argument enables the localization of form data input, as well as the rendered output. |
disabled | The disabled boolean argument, when set to True, disables a form field using the disabled HTML attribute so that it won’t be editable by users. |