---
title: "Scríobh do chéad ranníocaíocht do Django"
version: 6.1
locale: ga
source: https://docs.djangoproject.com/ga/6.1/intro/contributing/
canonical: https://djangodocs.dev/ga/6.1/intro/contributing/
---
# Scríobh do chéad ranníocaíocht do Django

## Réamhrá

Interested in giving back to the community a little? Maybe you've found a bug
in Django that you'd like to see fixed, or maybe there's a small feature you
want added (but remember that proposals for new features should follow the
[process for suggesting new features](/ga/6.1/internals/contributing/bugs-and-features/#requesting-features)).

Is é an bealach is fearr chun do chuid imní féin a fheiceáil ag cur ar ais chuig Django féin. D'fhéadfadh sé seo cosúil daunting ar dtús, ach tá sé ina cosán dea-thaistil le doiciméadú, tooling, agus pobal chun tacú leat. Siúlfaimid tú tríd an bpróiseas ar fad, ionas gur féidir leat foghlaim trí shampla.

### Cé dó an rang teagaisc seo?

> **See also**
>
> Má tá tú ag lorg teistiméireachta ar na sonraí maidir le ranníocaíochtaí cód a dhéanamh, féach an doiciméadú /inmheánach/ranníocaíocht/cód-scríobh/innéacs.

Maidir leis an rang teagaisc seo, táimid ag súil go bhfuil tuiscint bhunúsach ar a laghad agat ar an gcaoi a n-oibríonn Django. Ciallaíonn sé seo gur chóir duit a bheith compordach ag dul tríd na ranganna teagaisc atá ann cheana féin ar :d oc:writing your first Django app\</intro/tutorial01\>. Ina theannta sin, ba chóir go mbeadh tuiscint mhaith agat ar Python féin. Ach mura ndéanann tú, is leabhar iontach (agus saor in aisce) ar líne é [Dive Into Python](https://diveintopython3.net/) chun ríomhchláraitheoirí Python a thosú.

Iad siúd agaibh nach bhfuil cur amach acu ar chórais rialaithe leaganacha agus gheobhaidh Trac amach go bhfuil an rang teagaisc seo agus a naisc san áireamh ach go leor eolais chun tús a chur leis. Mar sin féin, is dócha gur mhaith leat níos mó a léamh faoi na huirlisí éagsúla seo má tá sé ar intinn agat cur le Django go rialta.

Den chuid is mó, áfach, déanann an rang teagaisc seo iarracht an oiread agus is féidir a mhíniú, ionas gur féidir é a úsáid don lucht féachana is leithne.

> **Cá háit le cabhair a fháil:**
>
> If you're having trouble going through this tutorial, please post a message
> on the [Django Forum](https://forum.djangoproject.com/) or drop by the [Django Discord server](https://chat.djangoproject.com) to chat with
> other Django users who might be able to help.

### Cad a chlúdaíonn an rang teagaisc seo?

Beimid ag siúl leat trí chur le Django den chéad uair. Faoi dheireadh an teagaisc seo, ba chóir go mbeadh tuiscint bhunúsach agat ar na huirlisí agus ar na próisis atá i gceist. Go sonrach, beimid ag clúdach na nithe seo a leanas:

- Suiteáil Git.
- Cóip de leagan forbartha Django a íoslódáil.
- Ag rith sraith tástála Django.
- Tástáil a scríobh le haghaidh do chuid athruithe.
- Scríobh an cód do do chuid athruithe.
- Do chuid athruithe a thástáil.
- Iarratas ar tharraingt a chur isteach.
- Cá háit le tuilleadh eolais a lorg.

Once you're done with the tutorial, you can look through the rest of
[Django's documentation on contributing](/ga/6.1/internals/contributing/).
It contains lots of great information and is a must-read for anyone who'd like
to become a regular contributor to Django. If you've got questions, it's
probably got the answers.

> **D'úsáideoirí Windows**
>
> Féach [Suiteáil Python](/ga/6.1/howto/windows/#install-python-windows) ar docs Windows le haghaidh treoir bhreise.

## Cód Iompair

Mar ranníocóir, is féidir leat cabhrú linn pobal Django a choinneáil oscailte agus cuimsitheach. Léigh agus lean ár [Cód Iompair](https://www.djangoproject.com/conduct/).

## Git á shuiteáil

Don rang teagaisc seo, beidh ort Git suiteáilte chun an leagan forbartha reatha de Django a íoslódáil agus brainse a ghiniúint do na hathruithe a dhéanann tú.

Chun seiceáil an bhfuil Git suiteáilte agat nó nach bhfuil, cuir `git` isteach i líne na n-orduithe. Má fhaigheann tú teachtaireachtaí ag rá nach bhféadfaí an t-ordú seo a aimsiú, beidh ort é a íoslódáil agus a shuiteáil, féach .

Mura bhfuil tú chomh eolach sin ar Git, is féidir leat níos mó a fháil amach i gcónaí faoina orduithe (nuair atá sé suiteáilte) trí `cabhair git` a chlóscríobh isteach i líne na n-orduithe.

## Cóip de leagan forbartha Django a fháil

Is é an chéad chéim chun cur le Django ná cóip den bhunchód a fháil. Ar dtús, . Ansin, ón líne ordaithe, bain úsáid as an ordú \`\` cd\`\` chun dul chuig an eolaire ina mbeidh tú ag iarraidh go mbeadh do chóip áitiúil de Django beo.

Íoslódáil stór cód foinse Django ag baint úsáide as an ordú seo a leanas:

```console
$ git clone https://github.com/YourGitHubName/django.git
```

*Windows*

```doscon
...\> git clone https://github.com/YourGitHubName/django.git
```

> **Nasc bandaleithead íseal?**
>
> You can add the `--depth 1` argument to `git clone` to skip downloading
> all of Django's commit history, which reduces data transfer from ~250 MB
> to ~70 MB.

Anois go bhfuil cóip áitiúil de Django agat, is féidir leat é a shuiteáil díreach mar a dhéanfá aon phacáiste a shuiteáil ag baint úsáide as `pip`. Is é an bealach is áisiúla chun é sin a dhéanamh ná trí virtual environment a úsáid, ar gné é atá tógtha isteach i Python a ligeann duit eolaire ar leith de phacáistí suiteáilte a choinneáil do gach ceann de do thionscadail ionas nach gcuirfidh siad isteach ar a chéile.

Is smaoineamh maith é do thimpeallachtaí fíorúla go léir a choinneáil in aon áit amháin, mar shampla i `.virtualenvs/` i d'eolaire baile.

Cruthaigh timpeallacht fhíorúil nua trí na nithe seo a leanas a rith:

```console
$ python3 -m venv ~/.virtualenvs/djangodev
```

*Windows*

```doscon
...\> py -m venv %HOMEPATH%\.virtualenvs\djangodev
```

Is é an cosán an áit a sábhálfar an timpeallacht nua ar do ríomhaire.

Is é an chéim dheiridh maidir le do thimpeallacht fhíorúil a bhunú ná é a ghníomhachtú:

```console
$ source ~/.virtualenvs/djangodev/bin/activate
```

Mura bhfuil an t-ordú \`\` foinse\`\` ar fáil, is féidir leat triail a bhaint as ponc ina ionad sin:

```console
$ . ~/.virtualenvs/djangodev/bin/activate
```

Caithfidh tú an timpeallacht fhíorúil a ghníomhachtú aon uair a osclaíonn tú fuinneog teirminéil nua.

> **D'úsáideoirí Windows**
>
> Chun do thimpeallacht fhíorúil a ghníomhachtú ar Windows, rith:
>
> ```doscon
> ...\> %HOMEPATH%\.virtualenvs\djangodev\Scripts\activate.bat
> ```

Taispeántar ainm na timpeallachta fíorúla atá gníomhachtaithe faoi láthair ar líne na n-orduithe chun cabhrú leat súil a choinneáil ar an gceann atá in úsáid agat. Déanfar aon rud a shuiteálann tú trí `pip` agus an t-ainm seo ar taispeáint a shuiteáil sa timpeallacht fhíorúil sin, scoite amach ó thimpeallachtaí eile agus ó phacáistí ar fud an chórais.

Téigh ar aghaidh agus suiteáil an chóip chlónáilte de Django roimhe seo:

```console
$ python -m pip install -e /path/to/your/local/clone/django/
```

*Windows*

```doscon
...\> py -m pip install -e \path\to\your\local\clone\django\
```

The installed version of Django is now pointing at your local copy by
installing in editable mode. You will immediately see any changes you make to
it, which is of great help when testing your first contribution.

## Seomra tástála Django a reáchtáil den chéad uair

Agus tú ag cur le Django tá sé an-tábhachtach nach dtugann d'athruithe cód fabhtanna isteach i réimsí eile de Django. Bealach amháin chun a sheiceáil go n-oibríonn Django fós tar éis duit do chuid athruithe a dhéanamh ná trí shraith tástála Django a reáchtáil. Má éiríonn leis na tástálacha go léir fós, is féidir leat a bheith réasúnta cinnte go n-oibríonn do chuid athruithe agus nár bhris tú codanna eile de Django. Mura ritheann tú sraith tástála Django riamh roimhe seo, is smaoineamh maith é a reáchtáil uair amháin roimh ré chun dul i dtaithí ar a aschur.

Sula ritheann tú an tsraith tástála, iontráil an chomhadlann Django `tests/` ag baint úsáide as an ordú `cd tests`, agus suiteáil spleáchais tástála trí rith:

```console
$ python -m pip install -r requirements/py3.txt
```

*Windows*

```doscon
...\> py -m pip install -r requirements\py3.txt
```

Má thagann tú ar earráid le linn na suiteála, d'fhéadfadh spleáchas a bheith in easnamh ar do chóras le haghaidh ceann amháin nó níos mó de na pacáistí Python. Téigh i gcomhairle le doiciméadú an phacáiste a bhfuil ag teip air nó cuardaigh an gréasán leis an teachtaireacht earráide a thagann ort.

Anois táimid réidh leis an tsraith tástála a rith:

```console
$ ./runtests.py
```

*Windows*

```doscon
...\> runtests.py
```

Now sit back and relax. Django's entire test suite has thousands of tests, and
it takes at least a few minutes to run, depending on the speed of your
computer.

While Django's test suite is running, you'll see a stream of characters
representing the status of each test as it completes. `E` indicates that an
error was raised during a test, and `F` indicates that a test's assertions
failed. Both of these are considered to be test failures. Meanwhile, `x` and
`s` indicate expected failures and skipped tests, respectively. Dots indicate
passing tests.

Go hiondúil is mar gheall ar leabharlanna seachtracha a bhíonn ag teastáil chun an tástáil a rith a bhíonn na trialacha scipeála in easnamh; féach [Na tástálacha go léir á rith](/ga/6.1/internals/contributing/writing-code/unit-tests/#running-unit-tests-dependencies) le haghaidh liosta spleáchais agus bí cinnte go suiteálann tú ceann ar bith do thástálacha a bhaineann leis na hathruithe atá á dhéanamh agat (ní bheidh aon ghá againn don rang teagaisc seo). Baineann roinnt tástálacha go sonrach le hinneal bunachair shonraí ar leith agus déanfar iad a scipeáil mura ndéantar iad a thástáil leis an inneall sin. Is é SQLite inneall an bhunachair shonraí do na socruithe réamhshocraithe. Chun na trialacha a rith ag baint úsáide as inneall difriúil, féach .

Nuair a bheidh na trialacha críochnaithe, ba chóir teachtaireacht a chur chugat ag cur in iúl duit cé acu ar éirigh nó nár éirigh leis an tsraith tástála. Ós rud é nach bhfuil aon athruithe déanta agat fós ar chód Django, ba chóir go mbeadh an tsraith tástála ar fad ba chóir \*\* pas a fháil. Má fhaigheann tú teipeanna nó earráidí déan cinnte gur lean tú gach ceann de na céimeanna roimhe seo i gceart. Féach [Tástálacha aonaid a rith](/ga/6.1/internals/contributing/writing-code/unit-tests/#running-unit-tests) le haghaidh tuilleadh eolais.

Tabhair faoi deara go mb'fhéidir nach mbeadh an brainse "príomh" Django is déanaí cobhsaí i gcónaí. Agus tú ag forbairt i gcoinne "príomh", is féidir leat Tógann comhtháthú leanúnach Django a sheiceáil \_\_ chun a chinneadh an bhfuil na teipeanna sonrach do do mheaisín nó má tá siad i láthair freisin i dtógáil oifigiúil Django. Má chliceálann tú chun amharc ar thógáil ar leith, is féidir leat féachaint ar an "Maitrís Cumraíochta" a thaispeánann teipeanna briste síos de réir leagan Python agus inneall bunachar sonraí.

> **Note**
>
> Don teagasc seo agus don ticéad a bhfuilimid ag obair air, is leor an tástáil in aghaidh SQLite, áfach, is féidir (agus uaireanta is gá) [na tástálacha a rith ag baint úsáide as bunachar sonraí eile](/ga/6.1/internals/contributing/writing-code/unit-tests/#running-unit-tests-settings). Agus athruithe comhéadain á ndéanamh agat, beidh ort :tag:na tástálacha Seiléiniam \<running-seiléiniam-tests\> a rith.

## Working on an approved new feature

For this tutorial, we'll work on a "fake accepted ticket" as a case study. Here
are the imaginary details:

> **Ticéad #99999 -- Ceadaigh tósta a dhéanamh**
>
> Ba chóir do Django feidhm `django.shortcuts.make_toast()` a chur ar fáil a fhilleann `'toast`'.

Cuirfimid an ghné seo agus na trialacha gaolmhara i bhfeidhm anois.

## Brainse a chruthú

Sula ndéanfaidh tú aon athruithe, cruthaigh brainse nua don ticéad:

```console
$ git checkout -b ticket_99999
```

*Windows*

```doscon
...\> git checkout -b ticket_99999
```

Is féidir leat aon ainm is mian leat a roghnú don bhrainse, is sampla é "ticket\_99999". Beidh na hathruithe ar fad a dhéanfar sa bhrainse seo sonrach don ticéad agus ní bheidh tionchar acu ar an bpríomhchóip den chód a chlónáil muid níos luaithe.

## Scríobh roinnt tástálacha do do thicéad

In most cases, for a contribution to be accepted into Django it has to include
tests. For bug fix contributions, this means writing a regression test to
ensure that the bug is never reintroduced into Django later on. A regression
test should be written in such a way that it will fail while the bug still
exists and pass once the bug has been fixed. For contributions containing new
features, you'll need to include tests which ensure that the new features are
working correctly. They too should fail when the new feature is not present,
and then pass once it has been implemented.

Bealach maith chun é seo a dhéanamh ná do thástálacha nua a scríobh ar dtús, sula ndéanann tú aon athruithe ar an gcód. Tugtar forbairt faoi thionchar tástála ar an stíl forbartha seo agus is féidir é a chur i bhfeidhm ar thionscadail iomlána agus ar athruithe aonair araon. Tar éis duit do chuid tástálacha a scríobh, ritheann tú leo ansin chun a chinntiú go dteipeann orthu go deimhin (ós rud é nach bhfuil an fabht sin socraithe agat nó gur chuir tú an ghné sin leis go fóill). Mura dteipeann ar do thástálacha nua, beidh ort iad a shocrú ionas go ndéanfaidh siad. Tar éis an tsaoil, níl tástáil aischéimnithí a théann beag beann ar cibé an bhfuil fabht i láthair an-chabhrach chun cosc a chur ar an fabht sin dul síos an bóthar.

Anois le haghaidh ár lámha-ar shampla.

### Tástáil a scríobh le haghaidh ticéad #99999

Chun an ticéad seo a réiteach, cuirfimid feidhm `make_toast()` leis an modúl `django.shortcuts`. Ar dtús táimid chun tástáil a scríobh a dhéanann iarracht an fheidhm a úsáid agus a sheiceáil go bhfuil cuma cheart ar an aschur.

Téigh chuig fillteán `tests/shortcuts/` Django agus cruthaigh comhad nua `test_make_toast.py`. Cuir an cód seo a leanas leis:

```
from django.shortcuts import make_toast
from django.test import SimpleTestCase

class MakeToastTests(SimpleTestCase):
    def test_make_toast(self):
        self.assertEqual(make_toast(), "toast")
```

Seiceálann an tástáil seo go bhfilleann an `make_toast()` ar `'toast'`.

> **Ach tá cuma kinda crua ar an rud tástála seo...**
>
> Mura raibh ort déileáil le tástálacha roimhe seo, is féidir leo breathnú beagán deacair a scríobh ar an gcéad amharc. Ar ámharaí an tsaoil, is ábhar mór *an-* é tástáil i gcláir ríomhaire, mar sin tá go leor eolais amuigh ansin:
>
> - Is féidir breathnú ar dtús maith ar thástálacha scríbhneoireachta do Django a fháil sna doiciméid ar :d oc:/topics/testing/overview.
> - Cuimsíonn Dive Into Python (leabhar ar líne saor in aisce d'fhorbróirí Python tosaigh) .
> - Tar éis duit iad siúd a léamh, más mian leat rud beag meatier chun do chuid fiacla a dhoirteadh isteach, tá doiciméadú Python :mod:'unittest' ann i gcónaí.

### Do thástáil nua a reáchtáil

Ós rud é nach bhfuil aon mhodhnuithe déanta againn ar `django.shortcuts` fós, ba cheart go dteipfeadh ar ár dtástáil. Rithimis na trialacha go léir san fhillteán `shortcuts` chun a chinntiú gurb é sin an rud a tharlaíonn i ndáiríre. `cd` chuig eolaire Django `tests/` agus rith:

```console
$ ./runtests.py shortcuts
```

*Windows*

```doscon
...\> runtests.py shortcuts
```

Má rith na tástálacha i gceart, ba cheart go bhfeicfeá teip amháin a fhreagraíonn don mhodh tástála a chuireamar leis, leis an earráid seo:

```pytb
ImportError: cannot import name 'make_toast' from 'django.shortcuts'
```

Má éirigh leis na tástálacha go léir, beidh tú ag iarraidh a chinntiú gur chuir tú an tástáil nua a thaispeántar thuas leis an bhfillteán cuí agus leis an ainm comhaid.

## Scríobh an cód do do thicéad

Ansin cuirfimid an fheidhm `make_toast()` leis.

Déan nascleanúint go dtí an fillteán `django/` agus oscail an comhad `aicearraí.py`. Ag an mbun, cuir leis:

```
def make_toast():
    return "toast"
```

Anois ní mór dúinn a chinntiú go dtéann an tástáil a scríobh muid níos luaithe, ionas gur féidir linn a fheiceáil an bhfuil an cód a chuir muid leis ag obair i gceart. Arís, téigh chuig eolaire Django `tests/` agus rith:

```console
$ ./runtests.py shortcuts
```

*Windows*

```doscon
...\> runtests.py shortcuts
```

Ba chóir go mbeadh gach rud pas a fháil. Mura bhfuil, cinntigh gur chuir tú an fheidhm leis an gcomhad ceart i gceart.

## Seomra tástála Django a reáchtáil don dara huair

Once you've verified that your changes and test are working correctly, it's
a good idea to run the entire Django test suite to verify that your change
hasn't introduced any bugs into other areas of Django. While successfully
passing the entire test suite doesn't guarantee your code is bug free, it does
help identify many bugs and regressions that might otherwise go unnoticed.

Chun an tsraith tástála Django ar fad a reáchtáil, `cd` isteach san eolaire Django `tests/` agus rith:

```console
$ ./runtests.py
```

*Windows*

```doscon
...\> runtests.py
```

## Cáipéisíocht Scríbhneoireachta

Is gné nua é seo, mar sin ba chóir é a dhoiciméadú. Oscail an comhad `docs/topics/http/shortcuts.txt` agus cuir an méid seo a leanas ag deireadh an chomhaid:

```rst
``make_toast()``
================

.. function:: make_toast()

.. versionadded:: 6.2

Returns ``'toast'``.
```

Since this new feature will be in an upcoming release it is also added to the
release notes for the next version of Django. Open the release notes for the
latest version in `docs/releases/`, which at time of writing is `6.2.txt`.
Add a note under the "Minor Features" header:

```rst
:mod:`django.shortcuts`
~~~~~~~~~~~~~~~~~~~~~~~

* The new :func:`django.shortcuts.make_toast` function returns ``'toast'``.
```

Chun tuilleadh eolais a fháil ar cháipéisíocht scríbhneoireachta, lena n-áirítear míniú ar cad atá i gceist leis an ngiolc `versionadded`, féach :d oc:'/internals/contributing/writing-documentation'. Cuimsíonn an leathanach sin míniú freisin ar conas cóip de na doiciméid a thógáil go háitiúil, ionas gur féidir leat réamhamharc a dhéanamh ar an HTML a ghinfear.

## Réamhamharc ar do chuid athruithe

Anois tá sé in am athbhreithniú a dhéanamh ar na hathruithe atá déanta sa chraobh. Chun na hathruithe go léir a chur ar stáitse réidh le tiomantas, rith:

```console
$ git add --all
```

*Windows*

```doscon
...\> git add --all
```

Ansin taispeáin na difríochtaí idir do chóip reatha de Django (le do chuid athruithe) agus an t-athbhreithniú a sheiceáil tú ar dtús níos luaithe sa rang teagaisc le:

```console
$ git diff --cached
```

*Windows*

```doscon
...\> git diff --cached
```

Bain úsáid as na heochracha arrow chun bogadh suas agus síos.

```diff
diff --git a/django/shortcuts.py b/django/shortcuts.py
index 7ab1df0e9d..8dde9e28d9 100644
--- a/django/shortcuts.py
+++ b/django/shortcuts.py
@@ -156,3 +156,7 @@ def resolve_url(to, *args, **kwargs):

     # Finally, fall back and assume it's a URL
     return to
+
+
+def make_toast():
+    return 'toast'
diff --git a/docs/releases/6.2.txt b/docs/releases/6.2.txt
index 7d85d30c4a..81518187b3 100644
--- a/docs/releases/6.2.txt
+++ b/docs/releases/6.2.txt
@@ -34,6 +34,11 @@
 Minor features
 --------------

+:mod:`django.shortcuts`
+~~~~~~~~~~~~~~~~~~~~~~~
+
+* The new :func:`django.shortcuts.make_toast` function returns ``'toast'``.
+
 :mod:`django.contrib.admin`
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~

diff --git a/docs/topics/http/shortcuts.txt b/docs/topics/http/shortcuts.txt
index 7b3a3a2c00..711bf6bb6d 100644
--- a/docs/topics/http/shortcuts.txt
+++ b/docs/topics/http/shortcuts.txt
@@ -271,3 +271,12 @@ This example is equivalent to::
         my_objects = list(MyModel.objects.filter(published=True))
         if not my_objects:
             raise Http404("No MyModel matches the given query.")
+
+``make_toast()``
+================
+
+.. function:: make_toast()
+
+.. versionadded:: 6.2
+
+Returns ``'toast'``.
diff --git a/tests/shortcuts/test_make_toast.py b/tests/shortcuts/test_make_toast.py
new file mode 100644
index 0000000000..6f4c627b6e
--- /dev/null
+++ b/tests/shortcuts/test_make_toast.py
@@ -0,0 +1,7 @@
+from django.shortcuts import make_toast
+from django.test import SimpleTestCase
+
+
+class MakeToastTests(SimpleTestCase):
+    def test_make_toast(self):
+        self.assertEqual(make_toast(), 'toast')
```

Nuair a bhíonn réamhamharc déanta agat ar na hathruithe, buail an eochair `q` chun filleadh ar líne na n-orduithe. Má d'fhéach an diff ceart go leor, tá sé in am na hathruithe a dhéanamh.

## Na hathruithe a dhéanamh

Chun na hathruithe a ghealladh:

```console
$ git commit
```

*Windows*

```doscon
...\> git commit
```

Osclaíonn sé seo eagarthóir téacs chun an teachtaireacht tiomantais a chlóscríobh. Lean an [commit message guidelines](/ga/6.1/internals/contributing/committing-code/#committing-guidelines) agus scríobh teachtaireacht mar seo a leanas:

```text
Fixed #99999 -- Added a shortcut function to make toast.
```

## An tiomantas a bhrú agus iarratas tarraingthe a dhéanamh

Tar éis duit na hathruithe a dhéanamh, seol chuig do forc é ar GitHub (cuir "ticket\_99999" in ionad ainm do bhrainse má tá sé difriúil):

```console
$ git push origin ticket_99999
```

*Windows*

```doscon
...\> git push origin ticket_99999
```

Is féidir leat iarratas tarraingthe a chruthú trí chuairt a thabhairt ar an leathanach [Django GitHub](https://github.com/django/django/). Feicfidh tú do chraobh faoi "Do chraobhacha a bhrúitear le déanaí". Cliceáil "Déan comparáid idir & iarratas tarraingt" in aice leis.

Ná déan é don rang teagaisc seo le do thoil, ach ar an gcéad leathanach eile a thaispeánann réamhamharc ar na hathruithe, chliceáilfeá "Cruthaigh iarratas tarraingthe".

## Na chéad chéimeanna eile

Comhghairdeas, d'fhoghlaim tú conas iarratas tarraingthe a dhéanamh chuig Django! Tá sonraí faoi theicnící níos forbartha a d'fhéadfadh a bheith ag teastáil uait in :d oc:/internals/contributing/writing-code/working-with-git.

Anois is féidir leat na scileanna sin a úsáid go maith trí chabhrú le codebase Django a fheabhsú.

### Tuilleadh eolais do ranníocóirí nua

Sula gcuirfidh tú isteach ar ranníoc le Django freisin, tá beagán faisnéise breise ar rannchuidiú ar cheart duit féachaint air:

- Ba cheart duit a chinntiú go léifidh tú doiciméadú Django ar [ticéid a éileamh agus iarratais tarraingthe a chur isteach](/ga/6.1/internals/contributing/writing-code/submitting-patches/). Clúdaíonn sé béasaíocht Trac, conas ticéid a éileamh duit féin, an stíl chódaithe a bhfuiltear ag súil leis (le haghaidh cód agus doiciméad), agus go leor sonraí tábhachtacha eile.
- Ba cheart do ranníocóirí céaduaire :d oc:documentation for first time contributors\</internals/contributing/new-contributors/\> a léamh freisin. Tá go leor comhairle mhaith ann dóibh siúd againn atá nua chun cabhrú le Django.
- Ina dhiaidh sin, má tá ocras ort fós le haghaidh tuilleadh eolais faoi rannchuidiú, is féidir leat brabhsáil i gcónaí tríd an gcuid eile de :d oc:Django's documentation on contributing\</internals/contributing/index\>. Tá tonna eolais úsáideach ann agus ba chóir go mbeadh sé ar do chéad fhoinse chun aon cheisteanna a d'fhéadfadh a bheith agat a fhreagairt.

### Do chéad ticéad fíor a aimsiú

Nuair a bheidh tú ag breathnú trí chuid den fhaisnéis sin, beidh tú réidh le dul amach agus ticéad de do chuid féin a fháil chun cur leis. Tabhair aird ar leith ar thicéid leis an gcritéar "piocadh éasca". Is minic a bhíonn na ticéid seo i bhfad níos simplí agus tá siad iontach do rannpháirtithe den chéad uair. Nuair a bhíonn tú eolach ar rannchuidiú le Django, is féidir leat tosú ag obair ar thicéid níos deacra agus níos casta.

Más mian leat tosú cheana féin (agus ní chuirfeadh aon duine an milleán ort!), déan iarracht féachaint ar an liosta  agus ar na . Má tá tú eolach ar thrialacha scríbhneoireachta, is féidir leat breathnú freisin ar an liosta . Ná déan dearmad na treoirlínte a leanúint maidir le ticéid a éileamh a luadh sa nasc chuig doiciméadú Django ar :doc: ticéad a éileamh agus craobhacha a chur isteach \</internals/ranníocaíocht/cód-scríobh/submitting-patches\>.

### Cad atá romhainn tar éis iarratas tarraingthe a chruthú?

Tar éis brainse a bheith ag ticéad, ní mór don dara sraith súl athbhreithniú a dhéanamh air. Tar éis iarratas tarraingthe a chur isteach, nuashonraigh meiteashonraí an ticéid trí na bratacha a shocrú ar an ticéad chun "tá paiste" a rá, "ní gá tástálacha", srl, ionas gur féidir le daoine eile é a fháil le haghaidh athbhreithnithe. Ní gá go gciallódh cur leis an gcód scríbhneoireachta ó thús i gcónaí. Is ranníocaíocht an-chabhrach é athbhreithniú a dhéanamh ar iarratais ar tharraingt oscailte freisin. Féach :d oc:internals/contributing/triaging-tickets le haghaidh sonraí.