Saravanan666/pypi-org huggingface dataset:
Package: cmsis-pack-manager
cmsis-pack-managercmsis-pack-manager is a python module, Rust crate and command line utility for managing current device information that is stored in many CMSIS PACKs. Users of cmsis-pack-manager may query for information such as processor type, flash algorithm and memory layout information in a python program or through the command line utility,pack-manager, provided as part of this module.CI StatusWheelsThe last step of CI uploads binary wheels tothis S3 bucket.DOCS!They live here:https://pyocd.github.io/cmsis-pack-manager/BuildingTo build cmsis-pack-manager locally, Install a stable rust compiler.
Seehttps://rustup.rs/for details on installingrustup, the rust
toolchain updater. Afterwards, runrustup update stableto get the
most recent stable rust toolchain and build system.After installing the rust toolchain and downloading a stable compiler,
runpython2 setup.py bdist_wheelfrom the root of this repo to
generate a binary wheel (.whlfile) in the same way as we release.For testing purposes, there is a CLI written in Rust within the rust
workspace as the packagecmsis-cli. For example From therustdirectory,cargo run -p cmsis-cli -- updatebuilds this testing
CLI and runs the update command, for example.
Package: cmsis-posmsk-codegen
cmsis_posmsk_codegencmsis_posmsk_codegen is a small utility to generate Pos and Msk definitions for registers, particularly for CMSIS projects. It can be used for any project but the Pos and Msk definitions are compatible with other definitions in CMSIS v5.Installation$ pip install cmsis_posmsk_codegenthen use:$ cmsis_posmsk_codegen reg.yamlRegister Definition (yaml)One or more registers are defined in a yaml file like this:REG_1:
  - FIELD_1: 2
  - FIELD_2: 3
  - RESERVED: 27
REG_2
  - RESERVED: 3
  - RESERVED: 5
  - FIELD_1: 24The field names are taken as it is for code generation. Since the generated code is C definitions, you probably want to write both register and field names in upper case.The number next to field name after colon is the number of bits of this field. It is assumed registers are 32-bit, so the total of bits of all fields in a register definiiton has to be 32-bit. If it is not, an error is generated and no output is given.If a field name is called RESERVED, no definition is generated, and its bits are skipped. Since this field is not generated, there can be more than one field named RESERVED. However, any other name (both registers and fields) has to be unique. If you want to keep a reserved field, name it with a number like RESERVED0.In addition to register and field names, a prefix is added to each definition. This prefix is the filename without extension of the input file given. Prefix is implicitly converted to uppercase.A yaml file named test.yaml with the contents above generates a Pos and Msk definition pair like this one for each field (so in total 3 pairs for example above, omitting the ones called RESERVED):#define TEST_REG_1_FIELD_1_Pos   2U
#define TEST_REG_1_FIELD_1_Msk   (3UL << ETM_REG_1_FIELD_1_Pos)An example yaml,etm.yaml, is given in github repo (but not in PyPI package). It describes ARM ETM registers.test.yamlandtest.expectedin the repo are used at travis build.
Package: cmsis-svd
Python CMSIS SVD Parser=======================This directory contains the code for a CMSIS SVD parser in Python.The parser is able to read in an input SVD and provide Python objectscontaining the information from the SVD.  This frees the developer(you) from having to worry about the SVD XML and each vendor's littlequirks.Install It----------You can install the latest stable version from pypi:```shpip install -U cmsis-svd```To install the latest development version by doing.  If this fails,you may need to update the version of pip you are using.```shpip install -U -e 'git+https://github.com/posborne/cmsis-svd.git#egg=cmsis-svd&subdirectory=python'````Example-------There's a lot of information you can glean from the SVDs for variousplatforms.  Let's say, for instance, that I wanted to see the namesand base address of each peripheral on the Freescale K20 (D7).  Since theK20 SVD is packaged with the library, I can do the following:```pythonfrom cmsis_svd.parser import SVDParserparser = SVDParser.for_packaged_svd('Freescale', 'MK20D7.xml')for peripheral in parser.get_device().peripherals:print("%s @ 0x%08x" % (peripheral.name, peripheral.base_address))```This generates the following output:```FTFL_FlashConfig @ 0x00000400AIPS0 @ 0x40000000AIPS1 @ 0x40080000AXBS @ 0x40004000DMA @ 0x40008000FB @ 0x4000c000FMC @ 0x4001f000FTFL @ 0x40020000DMAMUX @ 0x40021000CAN0 @ 0x40024000SPI0 @ 0x4002c000SPI1 @ 0x4002d000...```Example 2: Convert to JSON--------------------------The data structures representing the SVD data have the ability toconvert themselves to a dictionary suitable for serialization asJSON.  This works recursively.  To generate JSON data and pretty printit you can do something like the following:```pythonfrom cmsis_svd.parser import SVDParserparser = SVDParser.for_packaged_svd('Freescale', 'MK20D7.xml')svd_dict = parser.get_device().to_dict()print(json.dumps(svd_dict, sort_key=True,indent=4, separators=(',', ': ')))```Development-----------Once you have the code checked out, you can run the following fromthis directory to install dependencies:```shvirtualenv envsource env/bin/activatepip install -r dev-requirements.txt```Then, to run the tests:```shnosetests .```There are quite a few SVD files, so the tests take a bit.  If you havesome extra CPUs to throw at the problem, you can do the following:```shnosetes --process=8 .```Where `8` can be replaced with as many processes as you see fit.Generally, 2x the number of processors in your machine is a goodstarting place.Contributing------------Please open issues and submit pull requests on Github.
Package: cmsis-svd-codec
cmsis-svd-codecThis library allows you to programmatically create a svd file for your Microcontroller.
This is particularly useful when you have to parse the data from another
file descriptor format in order to build a svd file.How to installpip install cmsis-svd-codecExamplefromcmsis_svd_codecimportSvdDevicedevice=SvdDevice("RISC-V","CoffeeBean",version="1.0")# Fill the device top level details.device.add_description("Single core 5-stage pipeline RISC-V processor ...")device.add_license("""Licensed under the Apache License, Version 2.0, see LICENSE for details."""device.add_cpu("Ibex","rev01",device_num_Interrupts=2)device.add_address_config(width="32")# Add a peripheral to the device.peripheral=device.add_peripheral("UART0",version="0.1")peripheral.add_description("Simple UART peripheral")peripheral.add_base_address(0x4000_0000)peripheral.add_size(32)peripheral.add_interrupt(21)peripheral.add_address_block(offset=0x000,size=0x1000)# Add a register to the peripheral.reg=peripheral.add_register("FIFO_STATUS")reg.add_description("TX and RX fifo status.")reg.add_offset_address(0x0)# Add fields to the register.reg_field=reg.add_field("tx_full")reg_field.add_description("1 when the tx fifo is full, 0 otherwise.")reg_field.add_bit_range(first_bit=0,last_bit=0)reg_field.add_access_permission(read=True,write=False)reg_field=reg.add_field("tx_fifo_depth")reg_field.add_description("How may bit there are in the tx fifo.")reg_field.add_bit_range(first_bit=1,last_bit=4)reg_field.add_access_permission(read=True,write=False)# Create a svd file.device.dump('CoffeeBean.svd')ContributingPlease open issues and submit pull request to the repository.
Package: cmslib
READMEXCMS distribution standard library that will be hosted on PyPIWhat is this repository for?Quick summaryVersionLearn MarkdownHow do I get set up?Summary of set upConfigurationDependenciesDatabase configurationHow to run testsDeployment instructionsContribution guidelinesWriting testsCode reviewOther guidelinesWho do I talk to?Repo owner or adminOther community or team contact
Package: cmsmenu-redirect
IntroductionThis is aDjango CMSmenu plugin for replacing links in menus with the
redirected URL.InstallationFirst, you must installDjango CMSandDjango. For full details, see the installation
instructions for those packages.Installcmsmenu-redirectto your environment with a tool such asPIP,setuptools, orbuildout.Addcmsmenu_redirectanddjango.contrib.redirectsto theINSTALLED_APPSlist in your project’ssettings.pyand run thesyncdbcommand on yourmanage.py.What’s InsideThere is amenusNavigation Modifier that checks all nodes in the navigation
against the registered redirects (fromdjango.contrib.redirects). When a
node has a redirect, the url of that node is rewritten for the redirect.0.1 (2011/05/12)Menu modifier added
Package: cmsml
CMS Machine Learning Group Python package.The documentation of this Python package is hosted onreadthedocs.However, note that this documentation only covers the API and technical aspects of the package itself.
Usage examples and further techniques for working with machine learning tools in CMS, alongside a collection of useful guidelines can be found in thegeneral CMS ML group documentation.Clickhereto submit a feature suggestion!Docker imagesTo use the cmsml package via docker, checkout ourDockerHubwhich contains tags for several Python versions.TestingThe tests can be triggered withpytest-nautotestsand in general, they should be run for Python 3.7 to 3.11.
To run tests in a docker container, do# run the tests./tests/docker.shcmsml/cmsml# or interactively by adding a flag "i" to the command./tests/docker.shcmsml/cmsmli
>python-munittesttestsIn addition, before pushing to the repository,PEP 8compatibility should be checked withflake8via./tests/lint.shor using the docker container# run the tests./tests/docker.shcmsml/cmsmltests/lint.shSource hosted atGitHubReport issues, questions, feature requests onGitHub Issues
Package: cms-nbi-client
CMS-NBI-CLIENTCMS-NBI-CLIENT is a python package in the works. This package is not owned, supported or endorsed by Calix.
The goal of this package is to interact with the multiple NBIs(Northbound Interfaces) provided by a CMS(Calix Management System) instance.
Current scope of work is focused on the EXA line of E7 nodes. If you require work on other Calix products, feel free to put in a pull request.ResourcesOfficial Calix DocumentationCalix Management System (CMS) R14.1 Northbound Interface API GuideCalix E-Series (E7 OS R2.5) Engineering and Planning GuidePaul Clark's website contains a good amount of Calix docsFOR CURRENT CALIX DOCUMENTATION YOU WILL NEED A CALIX ACCOUNT TO GAIN ACCESS TO THEIR LIBRARYExamples--can be found in /Examples folderAuthors@somenetworkingLicenseGPL-3.0
Package: cms_perf
Sensor for use in the XRootDcms.perfdirective.
Measures system load, as well as cpu, memory, and network utilization,
to enable load-balancing in a cluster of multiple XRootD servers.With its support for individual re-configuration of each sensor reading,cms_perfallows to fine-tune or even re-define load reporting to your needs.
No need to hack any scripts, just install, configure, run.Installation and UsageThe sensor can be installed usingpip,
then configured using thecms.perfdirective.
See thedocumentationfor details and examples.Issues and ContributionsMaintenance and development ofcms.perfis hosted atGitHub.
For technical issues or suggestions, please open an issue ticket.
For direct code submissions, please open a pull request.
Package: cms-plots
CMS PlotsDescriptionUtilities for creating plots for computational materials/molecular science (CMS)This package provides tools for creating plotly graphs for e.g. band structure, DOS, and
other specialized plots for CMS applications.Free software: LGPL.v3 or laterDocumentation:https://molssi-seamm.github.io/cms_plots/index.htmlFeaturesDensity of states (DOS) plotsBand structure plotsCombined band structure & DOS plotsCreditsThis package was created withCookiecutterand themolssi-seamm/cookiecutter-seamm-pluginproject template.Developed by the Molecular Sciences Software Institute (MolSSI),
which receives funding from the National Science Foundation under
award ACI-1547580History2022.8.13 (13 August 2022)First release of a working version on PyPI.
Package: cmsplugin-accordion
CMSPlugin Accordion============django-cms plugin that allow to create accordions on the frontend.Installation------------To get the latest stable release from PyPi.. code-block:: bashpip install cmsplugin-accordionTo get the latest commit from GitHub.. code-block:: bashpip install -e git+git://github.com/bitmazk/cmsplugin-accordion.git#egg=cmsplugin_accordionTODO: Describe further installation steps (edit / remove the examples below):Add ``cmsplugin_accordion`` to your ``INSTALLED_APPS``.. code-block:: pythonINSTALLED_APPS = (...,'cmsplugin_accordion',)Don't forget to migrate your database.. code-block:: bash./manage.py migrate cmsplugin_accordionUsage-----1. Create a new ``Accordion`` instance via the Django admin.2. Create a few ``AccordionRow`` instances via the Django admin that belongto the Accordion instance you created before.3. Go to one of your CMS pages and add the ``Accordion Plugin``4. Edit the ``cmsplugin_accordion/accordion_plugin.html`` template to yourliking.That's it. You should now be able to embed accordions into your placeholders.Contribute----------If you want to contribute to this project, please perform the following steps.. code-block:: bash# Fork this repository# Clone your forkmkvirtualenv -p python2.7 cmsplugin-accordionmake developgit co -b feature_branch master# Implement your feature and testsgit add . && git commitgit push -u origin feature_branch# Send us a pull request for your feature branch
Package: cmsplugin-articles
It is a simple plugin that allows you to organize you article pages in a manner of a blog.
It does not break original page publishing workflow, but has some tricks to gather articles into a blog app.RequirementsIt works fine and tested underPython 2.7. The following libraries are requiredDjango>= 1.5django-cms>= 3.0 (we recommend to use Django CMS 3.0 and higher, contact us if you need prior CMS versions supports and have some issues)Installation$ pip install cmsplugin-articlesConfigure installed apps in yoursettings.pyINSTALLED_APPS = [
    # django contrib and django cms apps
    'cmsplugin_articles',
]Migrate your databasedjango-admin.py migrate cmsplugin_articlesUsageCreate a page in a common way, it will be a root page, an articles list;AddArticlesPluginto the page to you content placeholder, this will show a list of published articles;Create an article page as a child page, it will be shown automatocally in the list.CustomizationYou can customize this plugin by overriding the following templatescms/plugins/articles.html(plugin template layout)cms/plugins/article_teaser.html(if you want to change teaser template, e.g. useeasy-thumbnailsfor teaser images)cms/plugins/articles_pagination.html(pagination templates, if you want to add extra css classes or so)TemplatetagsThe plugin has a number oftemlatetagsused for teaser template, you should load them in your template
with{% load article_tags %}published_at, teaser_title and teaser_imageFilters which get articlePageinstance as an argumentpublished_atreturndatetimeobject for publication timeteaser_titlereturn teaser title as a stringteaser_imagereturnTeaserExtension.imageif existsteaser_textAsimple_tagwhich returns a teaser text. It accepts two parametersarticle_pagethe page that teaser belongs todefault_fromthe placeholder name. You can pass it if you want generate teasers automaticalyexact_columnsYou can use this template tag to split articles list into a column layout, e.g<div class="row">
  {% exact_columns articles 3 "vertical" as columns %}
  {% for column in columns %}
    <div class="col_6">
      {% for article in column %}
        {% include "cms/plugins/article_teaser.html" %}
      {% endfor %}
    </div>
  {% endfor %}
</div>RoadmapPython 3 supportChangelogThe changelog can be found atrepo’s release notesContributingFork the repo, create a feature branch then send me pull request. Feel free to create new issues or contact me via email.
Package: cmsplugin-articles-ai
=====================cmsplugin-articles-ai=====================Articles manager for Django CMSThis CMS app provides a way to manage articles. You need to implement the frontend by yourself.Getting started---------------1. Install with pip: ``pip install cmsplugin-articles-ai``- Note that if you want to use factories and management for generating test data, you needto install optional requirements too. You can do that either by manually installing themby running ``pip install cmsplugin-articles-ai[utils]``2. Add ``'cmsplugin_articles_ai'`` and ``'publisher'`` to ``INSTALLED_APPS``3. Add ``'publisher.middleware.PublisherMiddleware'`` to ``MIDDLEWARE_CLASSES``4. Implement frontend- This package includes only reference templates in (``templates/cmsplugin-articles-ai/``).- This package does not include any styling.Features--------**Attachments**Articles can have file attachments. The attachments can be image or pdf for example.**Categories**Articles can be categorized. Categories have their own list views that list the articlesbelonging in that article. Categories can be filtered by tags.**Publish states**Articles can have saved drafts which are not public. Draft can be published from admininterface with a push of a button.**Tags**Articles can be tagged and lists filtered by tags. Article can have any number of tags.Usage-----You will see additional publish workflow buttons in the article edit page.Article needs to be saved before you can preview the changes by clicking "Preview Draft" buttonin the top bar. You need to be logged in as staff user and have edit mode on when previewing the changes.If you are happy with the changes, go to the article edit page and click "Publish Draft" button.Changes will be visible to anonymous users only after publishing the draft.If you are updating existing project which has articles in the database already, you can use``python manage.py publish_model cmsplugin_articles_ai.models.Article`` command to generatepublished versions for all of them. Without a published version, article is not visibleto anonymous users!AddThis integration-------------------There is support for including AddThis social share buttons using ``{% load addthis_share %}`` andthen a ``{% render_addthis_share_buttons %}`` tag. Look for the usage example in the includedtemplate (``templates/cmsplugin_articles_ai/article_detail.html``).To enable this add the following declarations with your AddThis details to your project's ``settings.py``:| ``ADDTHIS_SHARE_BUTTONS_URL = "//s7.addthis.com/js/300/addthis_widget.js#pubid=..."``| ``ADDTHIS_SHARE_BUTTONS_CSS_CLASS = "addthis_sharing_toolbox"``|NOTE: Set ``ADDTHIS_SHARE_BUTTONS_URL`` so that it contains the URL provided by AddThis. Not the entireHTML snippet, just the URL inside src="...". ``ADDTHIS_SHARE_BUTTONS_CSS_CLASS`` should contain nameof the CSS class also provided by AddThis. This varies depending on which type of widget you chose.Installing for development--------------------------Use ``pip install -e /path/to/checkout`` to install as "editable" package to your venv
Package: cmsplugin-blocks
A set of DjangoCMS plugins for structured contents in CMS pages.The goal is to make rich page contents with less involved HTML than directly using
CKeditor. There is a plugin to implement common layout components and each one has its
own fields (title, image, content, link, etc..), they will be used in templates to
the build component parts.All plugin have a template field and possible CSS feature classes to select, so you can
make multiple component layout variants. You will define these available templates and
CSS feature classes from your settings.Plugins only supply plugin backend parts, there is no shipped frontend part like CSS or
Javascript in this package.FeaturesMany plugins to implement some common layout components;Album;Card;Container;Hero;Slider;Album can be filled from a ZIP with images;Included image thumbnailing;SVG soft support in image fields;Full test coverage;Included class for default settings withdjango-configuration(this is optional);DependanciesPython>=3.8;Django>=3.2;DjangoCMS>=3.11.0;djangocms-text-ckeditor>=5.0.1;django-smart-media>=0.3.0;LinksRead the documentation onRead the docs;Download itsPyPi package;Clone it on itsGithub repository;
Package: cmsplugin-blog-authors
An extension forcmsplugin-blogwhich allows to add multiple authors to a blog entry. This is based ondjango-people.InstallationYou need to install the following prerequisites in order to use this app:Djangodjango-cmscmsplugin-blogdjango-peopleIf you want to install the latest stable release from PyPi:$ pip install cmsplugin-blog-authorsIf you feel adventurous and want to install the latest commit from GitHub:$ pip install -e git://github.com/bitmazk/cmsplugin-blog-authors.git#egg=cmsplugin_blog_authorsAddcmsplugin_blog_authorsto yourINSTALLED_APPS:INSTALLED_APPS = (
    ...,
    'cmsplugin_blog_authors',
)UsageJust write a blog Entry and you will see a new inline for authors in the
Entry admin.RoadmapCheck the issue tracker on github for milestones and features to come.
Package: cmsplugin-blog-categories
An extension forcmsplugin-blogwhich adds categories to the blog. Out of the box cmsplugin-blog only supports
tags.InstallationYou need to install the following prerequisites in order to use this app:pip install Django
pip install django-cms
pip install cmsplugin-blog
pip install simple-translationIf you want to install the latest stable release from PyPi:$ pip install cmsplugin-blog-categoriesIf you feel adventurous and want to install the latest commit from GitHub:$ pip install -e git://github.com/bitmazk/cmsplugin-blog-categories.git#egg=cmsplugin_blog_categoriesAddcmsplugin_blog_categoriesto yourINSTALLED_APPS:INSTALLED_APPS = (
    ...,
    'cmsplugin_blog_categories',
)In your django-cms instance change theBlog Apphookto theBlog Categories
Apphook.UsageThis app includes all URLs of the original cmsplugin-blog, so if you were not
using an apphook but hooked the URLs into your mainurls.pymanually,
you should hook this app’surls.pyinstead.Display the category of an entryIn order to display an entry’s category, do the following:{% load cmsplugin_blog_categories_tags %}
{% get_category entry as category %}
Category:<a href="{{ category.get_absolute_url }}">{{ category.get_title }}</a>Display a list of all categoriesIn order to display a list of all available categories, do the following:{% load cmsplugin_blog_categories_tags %}
{% render_category_links exclude_empty=1 %}Use theexclude_emptyparameter if you want to show only those categories
that have posts.If you want to control the output of that tag, override the templatecmsplugin_blog_categories/category_links_snippet.htmlContributeIf you want to contribute to this project, please perform the following steps:# Fork this repository
# Clone your fork
$ mkvirtualenv -p python2.7 cmsplugin-blog-categories
$ pip install -r requirements.txt
$ ./logger/tests/runtests.sh
# You should get no failing tests

$ git co -b feature_branch master
# Implement your feature and tests
# Describe your change in the CHANGELOG.txt
$ git add . && git commit
$ git push origin feature_branch
# Send us a pull request for your feature branchWhenever you run the tests a coverage output will be generated intests/coverage/index.html. When adding new features, please make sure that
you keep the coverage at 100%.RoadmapCheck the issue tracker on github for milestones and features to come.