Saravanan666/pypi-org huggingface dataset:
Package: docly
doclyAutomatically generate docstrings for your python functionsMain documentation (FAQ and all)http://beta.thedocly.io/InstallingRequires python 3.6+NOTE THAT, if you are getting an error (in a fresh virtualenv in ubuntu it is observed) likeerror: invalid command 'bdist_wheel'then please install wheel by doingpip install wheelALSO NOTE that if you are getting an error to build tree-sitter because you do not have gcc installed then you can install it usingsudo apt-get install gcc python3-devfor other distros please checkhereFirst install setuptools-rust bypip install setuptools-rustThenpip install doclyUsingTo generate comments -docly-gen /path/to/file_or_folder_with_python_filesPlease note that if you do not have the necessary engine (models) downloaded before running the command (which is going to be case the first time you run this command) then it will download and set them up. Which may take a bit of timeIt will produce something like this (Shown on a single file but you can run it on a directory full of files also)The diff has been generated, do you want to see the suggestions for missing Docstrings? [Y/n]
Y
+-----------------+------------------------------+---------------------------------------+
| File Name       | Function Name                | Docstring                             |
+-----------------+------------------------------+---------------------------------------+
| simple_funcs.py | add                          | Add two numbers .                     |
| simple_funcs.py | check_if_even                | Checks if number is even .            |
| simple_funcs.py | check_even_numbers_in_a_list | Return list of numbers in base_list . |
| simple_funcs.py | open_file                    | Open a file .                         |
+-----------------+------------------------------+---------------------------------------+
Do you want to apply the suggestions? [Y/n]
Y
Applying diff
Diff applied. Good bye!Instead if you just want the above report and not to apply the chages then do this -docly-gen --no_generate_diff --print_report /path/to/file_or_folder_with_python_filesIf you want to revert the changes we applied then usedocly-restoreThis will bring back ALL the files that we had touched to the exact state before we applied the changes
Package: docmaker
DocmakerDocmaker is a framework to create forms to generate docx documents. It uses docxtpl and pyside6 libs.InstallYou need to have python 3.11 installed and install dockmaker with command below:pipinstalldocmakerCreating modelsIn order to create a model you have to create a new instance of DocModel defining the templates folder and the widget matrix as example below. You have to point the folder where your templates docx are.# app.pyfromdocmaker.guiimportwidgetsaswtfromdocmaker.gui.widgets.typesimportValidationErrorfromdocmaker.convertersimportStringListConverter,DateConverterfromdocmakerimportDocModelfromdocmakerimportAppfrompathlibimportPathimportosSCRIPT_DIR=Path(os.path.dirname(os.path.realpath(__file__)))defconvert_pericia(value:str)->dict:ret={}try:parts=value.split("/")ret['seq'],ret['rg'],ret['ano']=int(parts[0]),int(parts[1]),int(parts[2])returnretexcept:raiseValidationError("Valor incorreto")celular_model=DocModel("Celular",templates_folder=SCRIPT_DIR/"models/celular/templates",lists_folder=SCRIPT_DIR/"models/celular/listas",)celular_model.widgets=[[wt.SText("pericia",label="Pericia",placeholder="SEQ/RG/ANO",converter=convert_pericia),wt.SText("requisitante",label="Requisitante"),wt.SText("procedimento",label="Procedimento",placeholder="RAI ou inquérito"),wt.SText("ocorrencia_odin",label="Ocorrência ODIN"),wt.SSpinBox("n_objetos",label="N de objetos",required=True,default=1)],[wt.SText("data_odin",label="Data ODIN",converter=DateConverter()),wt.SText("inicio_exame",label="Inicio Exame",converter=DateConverter()),wt.SText("data_recimento",label="data de recebimento",converter=DateConverter()),],[wt.SText("n_quesito",label="Número quesito"),wt.SText("autoridade",label="Autoridade"),],[wt.SText("relatores",label="Relatores",placeholder="Relatores separados por vírgula",required=True,converter=StringListConverter()),wt.SText("revisores",label="Revisores",placeholder="Revisores separados por vírgula",converter=StringListConverter()),],[wt.SText("lacre_entrada",label="Lacre entrada"),wt.SText("lacre_saida",label="Lacre saída"),wt.SComboBox("n_midias","Nº Mídias",choices="opcoes_midias")]]@celular_model.pre_process()defpre_process(context):context['peritos']=context['relatores']+context['revisores']returncontextapp=App()app.add_docmodel(celular_model)app.run_gui()Run applicationpythonapp.py
Package: doc-manager
doc_manageris a django library for publishing documents in pdf and html format like privacy policy or term of use. It allows you to easily publish new versions of documents while preserving historical documents.InstallationYou can install module from pypi with pip:pip install doc-manageror install it directly from the repository with pip:pip install git+ssh://git@github.com/impicode/doc_manager.gitfor a specific branch:pip install git+ssh://git@github.com/impicode/doc_manager.git@branchnameRequirementsdjango>=3.2.17SetupAdd doc-manager to INSTALLED_APPS in settings.py file:INSTALLED_APPS = [
    ...
    'doc_manager',
    ...
]Define the model inour_app/models.py:from doc_manager.models import DocumentModel

class OurModel(DocumentModel):
    passRegister the model in django admin, where the documents are published.our_app/admin.pychanges:from doc_manager.admin import DocumentAdmin
from .models import OurModel

@admin.register(OurModel)
class OurAdmin(DocumentAdmin):
    model = OurModelCreate a view responsible for displaying the pdf or html document and assign a specific url to it.our_app/views.pychanges:from doc_manager.views import DocumentView
from .models import OurModel


class OurView(DocumentView):
    model = OurModelAdding path tourls.py:from our_app.views import OurView

urlpatterns = [
    ...
    path('see_document/', OurView.as_view(), name = 'see_document'),
]To add a link to the view of a published document, just:<a  href="{% url 'see_document' %}" target="_blank">See document</a>Don’t forget to migrate after adding a new model:python manage.py makemigrations
python manage.py migrateUsagelog in to the admin pagehead to app_name sectionadd documentpublish documentPublished document is now visible at the URL you previously specified in urls.pyTranslationsWe provide translations only to Polish. If you need any other language run in doc_manager directory:django-admin makemessages -l <language code>then in created file /locale/<language code>/LC_MESSAGES/django.po enter your translations and run:django-admin compilemessagesNow you have doc-manager app with your custom transltions ready to use in your project.ExampleIn main directory run:python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser
python manage.py runserverThen:Log in to the admin page (http://127.0.0.1:8000/admin/)Add document in OUR_APP/Our modelsPublish added documentGo tohttp://127.0.0.1:8000/see_document/to see added documentpre-commit InstallationIn case of developing doc_manager itself please install pre-commit before your first commit. You can do it with the following commands:pip install pre-commitThen in main directory:pre-commit installTestingTo run tests in main directory run:python runtests.pyYou can also run tests with tox. In main directory run:toxThat command will run tests discribed above, pre-commit style checks against all files and build a test package with poetry.
Package: docmd
docmdGenerate api-style github markdown-files from python docstrings.pip install docmdGenerate one file:docmd my_module > README.mdGenerate a whole folder full of documentation:docmd my_module -out docs -url https://github.com/atakamallc/docmd/blob/masterdocmd.docmdUsing docmd from python.Example:from docmd import DocMd

    d = DocMd()
    mod = d.importlib("module")
    d.module_gen(mod)DocMd(object)Generator class for producing md files..__init__(self, output_dir=None, source_url=None, output_fh=None)Construct a DocMd object:Args:output_dir: folder to write files to (optional)source_url: url for making source linksoutput_fh: file handle to use if no output_dir is specified (sys.stdout).import_module(name)Wrapper for importlib, in case we want to support more ways of specifying a module..module_gen(self, mod:module) -> strGenerate markdown, given an imported module with docstring comments.Returns: name of the module generated.
Package: docme
Introdocmeis a python application, which its goal is to reduce writing redundant rst documentations.it is similar to sphinx builtinautodocmodule, butdocmegoal is to create more cleaner look,thatautodocdoesn’t provide.InstallationSimply use pip installer:pipinstalldocmeOr download src files from Github/Pypi and write:pythonsetup.pyinstallfor developers, use:pythonsetup.pydevelopWhere To BeginSimple Startlets say your project’s tree is like so:.gitignoresrc/src/project/src/project/file.pyand you wish to create auto documentation of your project.simply usedocmecommand - which is an entry point which directs to :func:docme.cli.mainfunction:docmesrc/projectdocwheresrc/projectis the path to your main project files,anddocis the directory of docs that will be created.The result is that a new folder will be created nameddoc, and in it all relevant rst files,new tree will look like:.gitignoredoc/doc/api_reference/doc/api_reference/project/doc/api_reference/project/file.rstdoc/api_reference/project/index.rstdoc/api_reference/index.rstdoc/index.rstsrc/src/project/src/project/file.pynow you can simply addmakefile andconf.pyfor sphinx to compile the doc to html!cddocmakehtmlIncluding External Doclets say you already got some doc to include to the api reference:.gitignoredoc/doc/how_to_start/doc/how_to_start/advanced.rstdoc/how_to_start/intro.rstdoc/how_to_start/index.rstsrc/src/project/src/project/file.pyyou can includehow_to_startsection like so:docmesrc/projectdoc--extra-dochow_to_start/indexpay attention it is exactly the line you need to add to the mainindex.rst.newly created tree:.gitignoredoc/doc/how_to_start/doc/how_to_start/advanced.rstdoc/how_to_start/intro.rstdoc/how_to_start/index.rstdoc/api_reference/doc/api_reference/project/doc/api_reference/project/file.rstdoc/api_reference/project/index.rstdoc/api_reference/index.rstdoc/index.rstsrc/src/project/src/project/file.pyIn your doc you can reference classes and functions from your api!like so::class:`example<path.to.Class>`
Package: docments
DocmentsDocument parameters using comments.docmentsprovides programmatic access to comments in function parameters and return types. It can be used to create more developer-friendly documentation, CLI, etc tools. For instance, here is a function with docments-compatible comments:defadd(a:int,# the 1st number to addb:int,# the 2nd number to add)->int:# the result of adding `a` to `b`"Add `a` to `b`"returna+bThe library provides one main function, also nameddocments, which returns adictwith the parameter names as keys, and comments as values. The return value comment appears in thereturn.docments(add){'return': 'the result of adding `a` to `b`',
 'a': 'the 1st number to add',
 'b': 'the 2nd number to add'}This is the same format that__annotations__uses in Python.add.__annotations__{'a': int, 'b': int, 'return': int}InstallUsing pip:pip install docmentsUsing conda:conda install -c fastai docmentsDetailsIf you need more space document a parameter, place one or more lines of comments above the parameter, or above the return type:defadd(a:int,# The first operand# This is the second of the operands to the *addition* operator.# Note that passing a negative value here is the equivalent of the *subtraction* operator.b:int,# The result is calculated using Python's builtin `+` operator.# Note that this can be overridden for types using the `__add__` magic method)->int:"Add `a` to `b`"returna+bdocments(add){'return': "The result is calculated using Python's builtin `+` operator.\nNote that this can be overridden for types using the `__add__` magic method",
 'a': 'The first operand',
 'b': 'This is the second of the operands to the *addition* operator.\nNote that passing a negative value here is the equivalent of the *subtraction* operator.'}
Package: doc-mocker
Document Image MockerWarning:This project is completely experimental – do not use in real-world projects.This tool is intended to generate images of fake documents using content seeders.
It can be extended with plugins to add extra processing or content to the resulting images.UsageRunningdoc-mocker -hwill display the following helpusage:  [-h] [-n NUMBER_OF_PAGES] [-t {A4}] [-s {BASIC}] [-o OUTPUT_PATH]
        {generate}

positional arguments:
  {generate}            command to run

optional arguments:
  -h, --help            show this help message and exit
  -n NUMBER_OF_PAGES, --number-of-pages NUMBER_OF_PAGES
                        number of pages to generate (default: 1)
  -t {A4}, --page-type {A4}
                        page type (default: A4)
  -s {BASIC}, --page-seeder {BASIC}
                        page seeder (default: BASIC)
  -o OUTPUT_PATH, --output-path OUTPUT_PATH
                        output path (default: current path)ContributingEvery contribution is welcome.Be sure to your code isPEP-8compliant.
Useblackto fix your formatting before committing changes.blackmaindoc_mockerOptional: Install flake8 pre-commit hook to check your code before committing.flake8--install-hookgit
gitconfig--boolflake8.stricttrueCreate a pluginPlugins are auto-discovered if created as modules in the sub-packagedoc_mocker.pluginsusing thenamespace packagesconvention.Check thenoise pluginto get an idea on the required structure.Run testspython-mpytestCreditsView the full list ofcontributors.MITlicensed.
Package: doc-note-untangler
Doc Note UntanglerA tiny tool for extracting special blocks from docstrings and embedding them in a static web page.See an examplehere.MotivationGood documentation can be invaluable in the long term, but it takes effort which can be difficult to justify in the short term.
Not all projects are expansive libraries or frameworks, often they're just small applications with just a couple of pieces of critical business logic.
In those cases especially it may be tempting to forgo external documentation, which will of course bite you right back when it comes to onboarding new people or having to explain a particular behavior to your stakeholders over and over again.We have plenty of tools for building and hosting static pages and wikis from dedicated files but when it comes to documenting business logic, they require extreme vigilance to avoid discrepencies between docs and actual behavior.
Misleading docs are often worse than no docs at all.To avoid accumulation of discrepencies over time, it helps to put your docs near the code itself, so the engineer who modifies it can quickly spot new inaccuracies in docs and fix them.Module, class and function docstrings are a fine place for such docs, and this tool will let you easily define which parts of them may be relevant to external users and generate a static page for them.DetailsWhennotto use this tool:You're documenting a library, framework or a complex applicationYou're generating reference manuals for your apiWhen youmaywant to use this tool:Your application contains a several pieces of logic which should be documented externallyUsagepython-mdoc_note_untangler.cli<directory>ExamplesThe notes extractracted from this very project are hosted atgithub pages.
You will find the relevant docstrings in thesource code.ConfigurationThe CLI application offers some basic configuration such as setting the source paths and output dir.
Seepython -m doc_note_untangler.cli --helpfor all options.If you desire more complex customization, copypaste the source code into your own project and modify it at will.
Package: doco
Client library for docomo API written in Python.https://dev.smt.docomo.ne.jp/?p=docs.indexSupported apisDialogueSample code>>>fromdoco.clientimportClient>>>c=Client(apikey='YOUR_API_KEY')>>>res=c.send(utt='hello',apiname='Dialogue')>>>print(res){"utt":"はろー","yomi":"はろー","mode":"dialog","da":"30","context":"7DGIKMpQDE0zrQrYFAMqdw"}>>>print(c.last_response.status_code)200>>>print(c.last_response.headers){'Content-Length':'99','Connection':'keep-alive','Content-Type':'application/json;charset=UTF-8','Date':'Wed, 17 Dec 2014 05:28:28 GMT','asyncServiceInvoke':'false'}Cli example$exportDOCO_API_KEY="YOUR API KEY"$pythonexamples/dialogue_cli.py-uこんにちは'mode':'dialog','utt':'どうも','context':'N1liohyhkp6K7M80KS3bwg','da':'0','yomi':'どうも'}Interactive shell mode$exportDOCO_API_KEY="YOUR API KEY"$pythonexamples/dialogue_cli.py-iWelcometodocomodialoguecli.^Dtoexit.>>>こんにちははろー>>>Shiritori mode$exportDOCO_API_KEY="YOUR API KEY"$pythonexamples/dialogue_cli.py-i-sWelcometodocomodialoguecli.^Dtoexit.>>>しりとりリング>>>グッズ頭痛>>>海道のり>>>リンゴゴリラ>>>ラッパパスポート>>>
Package: doco-cli
Doco CLIdoco(dockercompose tool) is a command line tool
for working withDocker Composeprojects
(pretty-printing status, creating backups using rsync, batch commands and more).UsageExample calls:doco s *: Print pretty status of alldocker composeprojects in the current directory.doco s . -aa: Print most detailled status of adocker composeproject (including variables and volumes).doco r .: Equivalent ofdocker compose down --remove-orphans && docker compose up --build -d.doco backups create . --dry-run --verbose: See what would be done to create a backup of adocker composeproject.To explore all possibilities, rundoco -hor seedocs/doco-help.md.Installationpipxinstalldoco-cli
doco--install-completionOr install from source, seedocs/installation.md.ConfigurationTo create a backup, you need to either create adoco.config.tomlfile,
adoco.config.jsonfile
or set environment variables.Seedocs/configuration.md.DevelopmentTo start developing, seedocs/development.md.
Package: docode-managebd
docode-managebddocode-managebd es una libreria para manejar los procesos de la base de datos utlizando el framework Django==2.XTecnologiadocode-managebd se implementa con las siguientes tecnologias:Django- Python base framework!Instalaciondocode-managebd requierePythonv3+ para funcionar.Instalar por medio depip$pipinstalldocode-managebdUso:Una vez instalada la libreria en el entorno virtualImportar la libreria enPython:importdocode_managebd.procesos_bdasprocMetodos:Una vez que se realiza el import se pueden utilizar los metodos de la libreriaproc.obtener_campos(modelo)proc.verificar_formulario(request,modelo)proc.alta_registro(request,modelo)proc.eliminar_registro(request,modelo)proc.editar_registro(request,modelo)proc.modal_editar(id,modelo):Configuracion de TemplatePuedes utlizar tus propios templates con unoculto para identificar que tipo es:
[tipo] = ('nuevo', 'eliminar', 'editar')<inputclass="d-none"type="text"name="idForm"value="[tipo]">Por cada formulario envia el [id] del registro para su proceso solamente para eliminar y editar.Eliminar:<inputid="idEliminar"class="d-none"type="text"name="idEliminar"value="">Editar:<inputid="idEditar"class="d-none"type="text"name="idEditar"value="">VersionesVersion 0.0.5:Se implementa el uso de campos FileFiled para los modelosVersion 0.0.8:Al agregar registros estos pueden contener campos vaciosLicenciaMIT LicenseCopyright (c) 2019 DoCodePermission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
Package: doconce-publish
Publish: A Bibliographic Reference SystemOverviewPublish may be used for handling publication lists for research
institutions and departments, or for individual researchers. Publish
imports publication metadata (title, author, year of publication etc),
validates the imported data against a database of known venues, checks
for missing attributes, corrects common errors etc, and allows simple
filtering and generation of publication lists.For further information, refer to the Publish User Manual available in
the subdirectory doc/manual/ of this source tree.InstallationPublish is distributed on PyPi as publish-doconce, meaning that it can be installed with:pip install publish-doconceTo install Publish from this repository, simply typepython setup.py installDependencies:This version of Publish requires Python 3.6. Publish is not supported but probably still works on Python >= 2.6 (only tested for 2.7) with the levenshtein, future, and lxml modules installed:pip install python-Levenshtein
pip install future
pip install lxmlAuthorPublish was originally developed and implemented by
Anna Logganna@loggsystems.seat Logg Systems.
It is currently maintained by Anders Logglogg@chalmers.se.
Package: doconv
Convert AsciiDoc and DocBook files to DITAFree software: BSD licenseDocumentationAll documentation can be found in the “docs” directory or inhttp://doconv.rtfd.org.Release History0.1.0 (2013-10-16)Initial public release.Conversion from AsciiDoc and DocBook to DITA.Plugins’ orchestration to perform conversions not
achievable by a single plugin.0.1.1 (2013-10-20)Fix several installation issues.Remove temporarily python 3 support.0.1.2 (2013-11-09)Expand and improve documentation.Proper logging (available using –verbose CLI option).New plugins are now easier to develop.0.1.3 (2013-12-26)Add asciidoctor plugin.Add doconv command to query available document formats.0.1.4 (2014-03-05)Preparations for native packaging for Ubuntu and Arch Linux.0.1.5 (2016-10-17)Fixed issue converting notes from AsciiDoc to DITA.Added support for Python 3.4 and 3.5.0.1.6 (2016-10-17)Improve confusing error message under certain circumstances when using Python 3.0.1.7 (2019-01-29)Drop support for Python 2.6 and 3.3Update release processFix bug preventing doconv to work with latest version of some dependencies
Package: docopt2ragel
docopt2ragel makes command line interface parsing easy!docopt2ragel parses docopt USAGE text and outputs a Ragel finite state machine for parsing the CLI.You can then use Ragel to output the finite state machine into C source code.ExampleCreate a USAGE file using docopt’s declarative format. See below for example contents:dq-acommandlinetoolforduraqueuethedeadsimplequeueUsage:dqinfo<queue_file>dq--helpOptions:-h--helpPrintsashortusagesummary.Convert the USAGE file into a Ragel file:docopt2ragel.pyUSAGE>usage.rlConvert the Ragel file into a C file:ragelusage.rlImport the generated file into your source:#include"usage.c"intmain(intargc,char**argv){inte;options_topts;e=parse_options(argc,argv,&opts);if(-1==e){exit(-1);}void*qu=NULL;if(opts.help){show_usage();exit(0);}elseif(opts.info){qu=dqueuer_open(opts.queue_file);}if(qu)printf("Item count: %d\n",dqueue_count(qu));return1;}For real life examples see:https://github.com/willemt/duraqueuehttps://github.com/willemt/peardb
Package: docop-tasks
This package contains built-in tasks for docop.fetch_htmlFetch and store HTML from source URLs.Expects input source with a set of resources (URLs) to fetch
Output document fields set:
- 'reference' to the URL
- 'type' to "html"
- 'title' and 'html' set to the fetched HTML title & rendered HTML content
- 'uuid' generated from the URL
- 'modified' field set to Last-Modified header value