Saravanan666/pypi-org huggingface dataset:
Package: django-fakeinline
Author:Keryn KnightVersion:0.1.1fakeinlineprovides enough of the methods and attributes to trick theDjango Admininto displaying it when mounted as part of aninlinesdeclaration on a ModelAdmin. Where possible it does so without subclassing
real Django classes, as should be the case withDuck Typing.The 2 necessary subclasses are theFakeInlineclass itself, which must
subclassInlineModelAdmin, and themodelattribute,FakeModelwhich
must subclassModel, but is unmanaged and abstract, so there is nothing
touching the database.ReleaseStatusmasterWhy?!The most interesting thing about theDjango Adminis trying to bend it to
my will. This is an example of my winning.No really, why?Because it’s actually nicer to be able to wedge additional things into the admin,
without overriding thechange_form.htmltemplate on a per-model, per-app basis.Example usageHere’s a simple way of putting the classic wordsHello worldonto a ModelAdmin:class MyFormset(FakeFormset):
    # this probably works, but usually you'd point it at a template file.
    template = Template('{{inline_admin_formset.formset.get_data}}')

    def get_data(self, *a, **kw):
        return 'Hello world'

class MyInline(FakeInline):
    formset = MyFormSet

class MyAdmin(ModelAdmin):
    inlines = [MyInline]Whilst a silly example, it demonstrates how one might encapsulate display data
(charts, change history, etc) in a re-usable(ish) component for display on the
change view.TestsThere’s a couple infakeinline.tests… just enough to verify it doesn’t
raise an exception on GET or POST.The licenseIt’s theFreeBSD. There’s should be aLICENSEfile in the root of the repository, and in any archives.Copyright (c) 2016, Keryn Knight
All rights reserved.Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.Change history for fakeinline0.1.1Initial release
Package: django-fakejira-final-app
This is sample code used in the Real Python article [Writing an Installable Django App](???). The article describes how to take an app from an existing Django project and make it a stand-alone installable package avilable on PyPI.Installable AppThis app models a list of items on a receipt. Each item has a description and a cost. A receipt may reference multiple items.This app can be installed and used in your django project by:$pipinstallfakejira-testing-appEdit yoursettings.pyfile to include‘fakejira1’in theINSTALLED_APPSlisting.INSTALLED_APPS=[...'fakejira1',]Edit your projecturls.pyfile to import the URLs:url_patterns=[...path('/',include('fakejira1.urls')),]Finally, add the models to your database:$./manage.pymigratefakejira1
Package: django-fakejira-final-app-1
This is sample code used in the Real Python article [Writing an Installable Django App](???). The article describes how to take an app from an existing Django project and make it a stand-alone installable package avilable on PyPI.Installable AppThis app models a list of items on a receipt. Each item has a description and a cost. A receipt may reference multiple items.This app can be installed and used in your django project by:$pipinstalldjango-fakejira-testing-app-1Edit yoursettings.pyfile to include‘fakejira1’in theINSTALLED_APPSlisting.INSTALLED_APPS=[...'fakejira1',]Edit your projecturls.pyfile to import the URLs:url_patterns=[...path('/',include('fakejira1.urls')),]Finally, add the models to your database:$./manage.pymigratefakejira1
Package: django-fakemessages
django-fakemessages - Generate fake language files for yourDjango ProjectIntroductionLooking for missing translations in your Django project? Let's censor what is done and see what remains!ResourcesPackage on PyPI:https://pypi.org/project/django-fakemessages/Project on Github:https://github.com/pfouque/django-fakemessagesRequirementsDjango >=3.2Python >=3.8Translate-toolkit >=3.8.5How toInstall$ pip install "django-fakemessages"Register fakemessage in your list of Django applications:INSTALLED_APPS = [
    # ...
    "fakemessages",
    # ...
]Update your settings:if DEBUG:
    """Add our fake language to Django"""
    from django.conf.locale import LANG_INFO

    FAKE_LANGUAGE_CODE = "kl"

    LANG_INFO[FAKE_LANGUAGE_CODE] = {
        "bidi": False,
        "code": FAKE_LANGUAGE_CODE,
        "name": "▮▮▮▮▮▮▮▮",
        "name_local": "🖖 ▮▮▮▮▮▮▮",
    }
    LANGUAGES.append((FAKE_LANGUAGE_CODE, "🖖 ▮▮▮▮▮▮▮"))🎉 Voila!ContributePrinciplesSimple for developers to get up-and-runningConsistent style (black,ruff)Future-proof (pyupgrade)Full type hinting (mypy)Coding styleWe usepre-committo run code quality tools.Install pre-commithowever you like (e.g.pip install pre-commitwith your system python) then set up pre-commit to run every time you
commit with:>pre-commitinstallYou can then run all tools:>pre-commitrun--all-filesIt includes the following:poetryfor dependency managementRuff,blackandpyupgradelintingmypyfor type checkingGithub Actionsfor builds and CIThere are default config files for the linting and mypy.TestsTests packageThe package tests themselves areoutsideof the main library code, in a package that is itself a
Django app (it containsmodels,settings, and any other artifacts required to run the tests
(e.g.urls).) Where appropriate, this test app may be runnable as a Django project - so that
developers can spin up the test app and see what admin screens look like, test migrations, etc.Running testsThe tests themselves usepytestas the test runner. If you have installed thepoetryevironment,
you can run them thus:$ poetry run pytestor$ poetry shell
(django-fakemessages-py3.10) $ pytestCI.github/workflows/lint.yml: Defines and ensure coding rules on Github..github/workflows/test.yml: Runs tests on all compatible combinations of Django (3.2+) & Python (3.8+) in a Github matrix..github/workflows/coverage.yml: Calculates the coverage on an up to date version.
Package: django-fake-model
Simple library for creating fake models in the unit tests.This simple library allows to create fake models in your test without migrations, test apps and test tables in your base. All tables that you need will created/removed during the test.InstallInstall django-fake-model:pip install django-fake-modelQuickstartJust create a model in any file (Ex: in your test) and add decorator@YourModel.fake_meto test method or test class.fromdjango_fake_modelimportmodelsasffromdjango.dbimportmodelsfromdjango.testimportTestCase,TransactionTestCaseclassMyFakeModel(f.FakeModel):name=models.CharField(max_length=100)@MyFakeModel.fake_meclassMyFakeModelTests(TestCase):deftest_create_model(self):MyFakeModel.objects.create(name='123')model=MyFakeModel.objects.get(name='123')self.assertEqual(model.name,'123')classMyFakeModelFunctionTest(TestCase):@MyFakeModel.fake_medeftest_create_model(self):MyFakeModel.objects.create(name='123')model=MyFakeModel.objects.get(name='123')self.assertEqual(model.name,'123')classRelatedModel(f.FakeModel):text=models.CharField(max_length=400)classNyModel(f.FakeModel):text=models.CharField(max_length=400)related_model=models.ForeignKey(RelatedModel)@NyModel.fake_me@RelatedModel.fake_meclassTestRelatedModelsClassDecorator(TransactionTestCase):deftest_create_models(self):related_model=RelatedModel()related_model.text='qwerty'related_model.save()my_model=NyModel()my_model.test='qwerty'my_model.related_model=related_modelmy_model.save()self.assertIsNotNone(my_model)self.assertIsNotNone(related_model)Development:To develop on this locally withDocker, install the Docker Engine andDocker Compose. Then you can build the Docker image and run the tests
on all tox activities(this also uses a shared pip cache to reduce download
times):docker-compose up -d pg mysql
docker-compose run --rm testIf you wanna run just one Tox activity you can specify that as well:docker-compose run --rm test tox -e py35-dj19-mysql-unittestIf you add any dependencies or change the tox configuration, you have
to rebuild the image:docker-compose buildIt will share this folder with the Docker containers, so thatCookiecutter Tools Used in Making This Packagecookiecuttercookiecutter-djangopackageHistory0.1.4 (2016-02-08)Fix class decoratorfake_mefor nose tests0.1.3 (2015-12-23)Fix issue #1 Multiple Fake Models. Thanks to Saul Shanabrook (@saulshanabrook)Add support for developing with Docker. Thanks to Saul Shanabrook again0.1.2 (2015-11-13)Added Django 1.9 supportAdded travis config generatorAdded nose testsRemove tests for Django master0.1.1 (2015-09-28)Added tests with different databases.0.1.0 (2015-09-16)First release on PyPI.
Package: django-fakemoneyd
FakeMoney is a Django app to provide light models for real world currencies and virtual currencies you want to make.Quick startAdd“fakemoney”to your INSTALLED_APPS setting like this:INSTALLED_APPS = [
    ...
    'fakemoneyd',
]Include the fakemoneyd URLconf in your project urls.py like this:path('fakemoney/', include('fakemoneyd.urls')),Runpython manage.py migrateto create the fakemoney models.Runpython manage.py feed_currenciesin order to feed all the existing real world currencies.Visithttp://127.0.0.1:8000/fakemoney/to participate in the poll.
Package: django-fakeredis
Easier usefakeredisin Django.Installpip install django-fakeredisWhy use it?I have experienced many times to find bugs which is caused by mutiple fakeredis instances in tests.
We just want to use fakerredis like redis with one redis-server and different connections and can debug with MONITOR command in redisFeatures:One fakeredis server with mutiple connections for tests like the way of using redis.Combine override settings to Local-memory and fakeget_redis_connection,django's cacheTo disable the fake action with passing env: "NOFAKE_REDIS=1"NOFAKE_REDIS=1 python manage.py testBefore you usedjango_fakeredis, your tests code maybe like that:server=fakeredis.FakeServer()@override_settings(CACHES={"default":{"BACKEND":"django.core.cache.backends.dummy.DummyCache"}})@patch('foo.get_redis_connection',fakeredis.FakeRedis(server=server)deftest_sth():....Now your can just:@FakeRedis("yourpath.get_redis_connection")deftest_sth():...Usagefromdjango_fakeredisimportFakeRedis@FakeRedis("yourpath.get_redis_connection")deftest_foo():...fromdjango_fakeredisimportFakeRediswithFakeRedis("yourpath.get_redis_connection"):foo()fromdjango_fakeredisimportFakeRediswithFakeRedis("yourpath.cache"):foo()NOTEIf you want to mockdjango.core.cache.cachewith fakeredis, django-fakeredis do nothing but just override CACHE settings intoLocal-Memoryfor using the internal cast. So there are two mocked redis instance for django.cache and get_redis_connection .If you want to use more redis commands, such as: sets, list...,  you may need usedjango_redis, and cast the result by hand.django.cache:from django.core.cache import cache
cache.set("key", 2)
assert cache.get("key") == 2you have to cast by hand, when using fakeredis or django_redis directly, you have to cast by hand:import fakeredis
con = fakeredis.FakeStrictRedis()
con.set("key", 2)
assert con.get("key").decode('utf8') == "2"if you have a problem that mock is not worked, you may should to seewhere to patch
Package: django-faktura
=======Faktura=======.. image:: https://img.shields.io/pypi/pyversions/django-faktura.svg:target: https://pypi.org/project/django-faktura/.. image:: https://codebeat.co/badges/76c75008-f8a2-4ace-8ec4-c4f1b9183c6c:target: https://codebeat.co/projects/github-com-ricco386-django-faktura-master.. image:: https://travis-ci.com/ricco386/django-faktura.svg?branch=master:target: https://travis-ci.com/ricco386/django-faktura.. image:: https://img.shields.io/github/license/ricco386/django-faktura.svg:target: https://github.com/ricco386/django-faktura/blob/master/LICENSEFaktura is a simple Django app to conduct Web-based invoice generation and evidence.Quick start-----------1. Add "faktura" to your INSTALLED_APPS setting like this::INSTALLED_APPS = [...'faktura',]2. Include the polls URLconf in your project urls.py like this::path('invoices/', include('faktura.urls')),3. Run `python manage.py migrate` to create the faktura models.4. Start the development server and visit http://127.0.0.1:8000/admin/to manage your invoices (you'll need the Admin app enabled).5. Visit http://127.0.0.1:8000/invoices/ to view the invoices list.Support-----I did this app because SPy o.z. (non profit supporting Slovak Python community) neededsomething for invoice evidence. I like to program and I wanted to try design a cleanDjango app and learn one or two things about testing stand alone app and packaging.If you like what I do (stuff like this django app, or my role in community), you can buy me a coffee:.. image:: https://img.shields.io/badge/Donate-PayPal-green.svg:target: https://paypal.me/ricco386If you use this app for your business consider makeing a recurent donation:.. image:: http://img.shields.io/liberapay/goal/RicCo.svg?logo=liberapay:target: https://liberapay.com/RicCo/donate
Package: django-fancybox
This is aDjangointegration ofFancybox.Installationpipinstalldjango-fancyboxExternal dependenciesjQuery - This is not included in the package since it is expected that in most scenarios this would already be available.SetupAddfancyboxtoINSTALLED_APPS:INSTALLED_APPS+=('fancybox',)Be sure you have thedjango.template.context_processors.requestprocessorTEMPLATES=[{...'OPTIONS':{'context_processors':[...'django.template.context_processors.request',],},},]and just includefancyboxtemplates{%include"fancybox/fancybox_css.html"%}{# Before the closing head tag #}{%include"fancybox/fancybox_js.html"%}{# Before the closing body tag #}When deploying on production server, don’t forget to run :pythonmanage.pycollectstaticUsageExtend base template for ajax requests{%extendsrequest.is_ajax|yesno:"fancybox/base.html,base.html"%}Addclass="fancybox"to a link, and set the href to a page you want to display<adata-fancyboxdata-type="ajax"href="{%url'remote.html'%}"class="fancybox">Click here</a>Please seeexampleapplication. This application is used to manually test the functionalities of this package. This also serves as a good example.You need only Django 1.4 or above to run that. It might run on older versions but that is not tested.Licensedjango-fancyboxis released under the BSD license.
Package: django-fancy-cronfield
A nice and customizable cron field with great, easy to use UI.Attention!To propose features, always open pull requests on thedevelopbranch.
It’s the branch for features that will go into the next django fancy cronfield feature release.For fixes for 0.1.x releases, please work on support/0.1.x which
contains the next patch release for 0.1.x series.Themasterbranch is the current stable release, the one released on PyPI.
Changes based onmasterwill not be accepted.FeaturesCron widget providing nice gentle select UICron format validationCustom django fieldAbility to specify a daily run limitRequirementsFancy cron field requires Django version 1.5 up to 1.9, Python 2.6, 2.7, 3.3,
3.4 and python-crontab 1.9.3.DocumentationPlease head over todocumentationfor all the details on how to install,
customize and use the django fancy cronfield.Tutorialhttp://django-fancy-cronfield.readthedocs.org/en/latest/intro/index.htmlInstallationpipinstalldjango-fancy-cronfieldBasic usageAdd‘fancy_cronfield’to yourINSTALLED_APPS, then useCronFieldlike
any regular model field:fromdjango.dbimportmodelsfromfancy_cronfield.fieldsimportCronFieldclassMyModel(models.Model):timing=CronField()Getting HelpPlease Write to ourmailing list.CreditsCrontab API features borrowed frompython-crontab.
Package: django-fancy-cronfield-alt
A nice and customizable cron field with great, easy to use UI.FeaturesCron widget providing nice gentle select UICron format validationCustom django fieldAbility to specify a daily run limitRequirementsFancy cron field requires Django version 1.11 up to 2.2, Python 3.6, 3.7, 3.8, and python-crontab 1.9.5.Installationpython-mpipinstalldjango-fancy-cronfield-altBasic usageAdd‘fancy_cronfield’to yourINSTALLED_APPS, then useCronFieldlike
any regular model field:fromdjango.dbimportmodelsfromfancy_cronfield.fieldsimportCronFieldclassMyModel(models.Model):timing=CronField()Creditsdjango-fancy-crontab was created by@saeedsq.Crontab API features borrowed frompython-crontab.
Package: django-fancy-formset
django-fancy-formsetThis is a plain JavaScript library to let users add and remove forms in a Django inline
formset. It can be installed from PyPI as a Django app, from NPM as a JavaScript module,
or linked to directly from your HTML.Features:No dependencies, just 5kB of plain JavaScriptApply to formsets manually, or automatically via adata-attributeOptional Django app to simplify usageRaises events to allow for customisationClass based and designed to be extendedDefault styling availableQuickstart using PythonInstall with:pipinstalldjango-fancy-formsetAdd to yourINSTALLED_APPS, then create your formsets using the provided
fancy formset classes:fromfancy_formsetimportFancyInlineFormSetBookInlineFormSet=forms.inlineformset_factory(Author,Book,formset=InlineFancyFormSet,)then leave it to Django to render your formset:{{formset.media}}<form method="post">{%csrf_token%}{{form.as_p}}{{formset.as_p}}<button type="submit">Save</button></form>See theDjango installation documentationfor more detailsQuickstart using JavaScriptThe Python package is a thin wrapper around the JavaScript package. For more control,
you can integrate it yourself.Add to your page directly usingunpkg:<html><head><!-- Optional styles --><linkrel="stylesheet"href="https://unpkg.com/django-fancy-formset@^1/dist/formset.min.css"></head><body><!-- Django formset goes here --><scriptsrc="https://unpkg.com/django-fancy-formset@^1"></script><script>formset.init();</script></body></html>You can also use it in your bundler or browser as module - see theJavaScript-only installation documentationfor more detailsRender your formset in your Django template. The template structure which will work with
the default configuration is:<form method="post">{%csrf_token%}{{form.as_p}}<h2>Formset</h2><div data-formset="{{formset.prefix}}">{# Formset container to target #}{{formset.management_form}}{# Add the management form #}<fieldset style="display: none">{# Add and hide the empty form #}{{formset.empty_form.as_p}}</fieldset>{%forforminformset%}<fieldset>{# Each formset form has a container #}{{form.as_p}}{# Actual form layout doesn't matter #}</fieldset>{%endfor%}</div><button type="submit">Save</button></form>This can all be customised with options passed asformset.init(options)- see theconfiguration documentationfor details.Find out moreFor full installation and usage instructions, as well as information on events, the API
and customisation, see thedocumentation.
Package: django-fancytree
Django Fancytree Widget----------------------django-fancytree provides a widget using the fancytree js library torender a forms.ModelMultipleChoiceField as a tree with selectable andcollapsable nodes.See included project 'treewidget' as an example. Widget is used inModelMultipleChoiceField and allows user to select multiple categories.Requirements------------django, django-mptt, jquery, jquery-uiUsage-----::from fancytree.widgets import FancyTreeWidgetcategories = Category.objects.order_by('tree_id', 'lft')class CategoryForm(forms.Form):categories = forms.ModelMultipleChoiceField(queryset=categories,widget=FancyTreeWidget(queryset=categories))In this example Category is a model registered with django-mptt.Widget accepts **queryset** option, which expects pre-ordered queryset by"tree_id" and "lft".If you want to adjust tree data creation, you can define 'get_doc' method onyour model. Example:::def get_doc(self, values):doc = {"title": name, "key": self.pk}if str(self.pk) in values:doc['select'] = Truedoc['expand'] = Truereturn doc
Package: django-faq
ThisDjangoapplication provides the ability to create and manage lists of
Frequently Asked Questions (FAQ), organized by topic.This project is still under development, though several medium-to-large
websites are currently using it in production. The plan is to get a stable
version with a full test suite and documentation out the door in the coming
months.TODO’sBelow are tasks that need done, features under consideration, and some
reminders for the future.Write tests for faq.Wire up testing on travis-ci.org.Write tests for haystack bits.Write general documentation, and specifically,The change of modified date field behavior. (Dropped null=True, now
has a date upon creation.) Write migration if necessary.Document removal of custom template name field on Topic. (The feature made
little sense given the various URL/view setups.) Write migration if
necessary.Note supported versions of Python, Django, and Haystack.Put documentation on readthedocs.org.FeaturesCreate a better interface for ordering questions within a topic.Consider if/how to add ordering to Topics. (This is complicated because of
site relations.)Consider making the requirement fordjango.contrib.sitesoptional.In the future, when dropping Django 1.2 supportUpdate to class-based generic viewsMove from Question.save() to model validation?
Package: django-faq-ds
django-faq_dsdjango-faq_ds is a Django app to use for demiansoft.Quick startAdd "faq" to your INSTALLED_APPS setting like thisINSTALLED_APPS=[...'faq',]코드를 넣고자 하는 위치에 다음을 추가 한다.{% load faq_tags %}
{% make_faq %}context examplecontext={"theme":"bethany_ds","faq":[{"q":"수업은 어디서 진행되나요?","a":"일대일 수업의 경우, 편안한 분위기를 선호하는 학습자는 카페에서, 조용한 공간을 선호하는 학습자는 스터디룸에서 진행됩니다. 현재 모든 수업은 강남역과 삼성역 사이에서 진행되고 있습니다. Skype 및 Zoom 을 통한 온라인 수업도 가능합니다."},{"q":"클래스는 어떻게 진행되나요?","a":"수업 중에 선생님은 학생에게 다양한 주제에 대해 질문하고 문법적 오류, 새로운 어휘 및 표현 등을 체크하며 자연스러운 대화를 이어갑니다. 체크된 내용들은 레슨노트로 작성되어 수업 후 학생의 이메일로 전송됩니다.<br>시험, 면접, 발표 준비 수업의 경우 자연스러운 대화 스타일에서 모의 면접 스타일로 초점이 바뀝니다. 학생들은 수업에서 새로운 어휘, 표현 및 수정된 문장을 연습할 수 있습니다. 일반적으로 수업에서 학생은 70~80%를, 교사는  20~30%를 이야기합니다."},{"q":"초보자도 클래스를 신청할 수 있나요?","a":"영어회화 경험이 없는 초보자도 환영합니다! 물론 대화 시작 전에 기본적인 어휘와 문장 패턴에 대한 기본 학습이 진행될 것입니다. 수업 때 선생님은 영어만 사용하나 초보자들을 위해 필요시 한국어를 사용할 수 도 있습니다. 학생들이 표현하려고 하는 것을 표현할 수 있는 매우 편안한 분위기가 될 것입니다. 실수를 하거나 완벽판 표현을 할 수 없는 것은 지극히 정상적이고 자연스러운 일입니다. 이것은 초보자들뿐만 아니라 모든 레벨의 학습자 모두 마찬가지입니다."},{"q":"클래스를 위한 준비물이 있나요?","a":"네! 수업에는 영어로 말하고자하는 열정과 스피킹 능력을 향상시키고 싶다는 마음만 가지고 오시면 됩니다."},{"q":"번역 또는 통역서비스도 제공하나요?","a":"현재 통역, 번역수업은 없습니다. 그러나, 영어 문장은 수업 시간에 교정할 수 있습니다. 교정 가능한 문서로는 논문, 비즈니스 이메일, 대학 과제, 발표 스크립트 등이 있습니다."},{"q":"온라인 클래스도 있나요?","a":"Skype 및 Zoom 수업이 가능합니다. 모든 수업은 온라인 수업으로 대체 가능합니다.  온라인 수업은 대면 수업과 같은 방식으로 진행되며, 레슨 노트와 수업 자료는 화면으로 공유됩니다."}]}
Package: django-farm
A pluggable django application to keep track of animals on a farm. Simple.ModelsSpeciesname -> char
slug -> from(name)Breedspecies -> species
name -> char
slug -> from(name)Animalname -> char
slug -> from(name)
breed -> breed
mother -> animal
father -> animal
birthday -> date
birthtime -> time
description -> text
photos -> photo[photologue]ProductTypename -> char (e.g. produce, meat, soap, preserves…)
slug -> from(name)
description -> textProductname -> char
type -> product type
description -> text
photos -> photo(s)[photologue]
price -> float
unit -> char (e.g. dozen, lb, half, whole)
flexible_price -> char