Saravanan666/pypi-org huggingface dataset:
Package: d0da
Wooting D0DA ProtocolIntroductionWooting has been very generous in supplying Open Source (!) SDKs for their hardware, only, the SDKs aren't
very thoroughly documented, limited to a single use case and written in C.This repository tries to fill in these gaps, it generated the packets and the used fields are described. It also
describes what the packets do and in what order they should be sent.FeaturesTechnical documentationCommand line interface (d0da-cli) for sending packets to the keyboardUnit testsLimitationsLinux only (for now)Wooting 60HE (ARM) only, though the packets should be compatible with other keyboards.InstallationRun:pipxinstalld0da
Package: d1ct
d1ct - a hybrid object/mappingFEATURESdirectly inherited from dictaccessible by attribute.   o.x == o['x']This works also for all corner cases.json.dumps json.loadsvars() works on it!hashable! (should not yet trust on it, though)autocomplete works even if the objects comes from a listbest of all, it works recursively. So all inner dicts will become d1cts too.CHANGELOGversion 1.0.5
-   added the capability to not only accept dict-like mappings, but also lists of objects
    which will be returned as a list of d1ct-objects. 
    So no worries if you send it the json.loads output (which can be either a list or dict)NO DOWNSIDES?oh hell yeah it got downsidesthe performance which is a magnitude slower (~6x) than builtin dictto give you an impression of timeit results:d1ct0.262892300001112740.25431089999619870.257437200023559850.25605390002601780.25567369998316280.254788699996424840.25410109999938870.25520089999190530.26511310000205410.25846979999914765dict0.049287500005448240.049029000016162170.0490493999968748540.0506449999811593440.04969919999712140.049408999999286610.04975409997859970.049596900003962220.049392499990062790.04959330000565387So... this implementation might have side effects which I did not notice, because of different use cases or whatever.Usage / Testingimport d1ct

d = d1ct({"a": 1, "b": {"b1": "c1"}}, kw1=1, kw2=2)
d["z1"] = {}
d.z1.update({"yyyy": 2323232})

assert d.a == d['a'] == 1
assert d.z1 == d['z1'] == {'yyyy': 2323232}
assert d == {'a': 1, 'b': {'b1': 'c1'}, 'kw1': 1, 'kw2': 2, 'z1': {'yyyy': 2323232}}
assert type(d.z1) is d1ct

d.z1.update({"yyyy": 2323232})
assert type(d.z1.yyyy) is int

d.z1.update({"yyyy": {"xbb": [1, 2, 23]}})
assert type(d.z1.yyyy) is d1ct

import json
json.dumps(d)

d |= {'more_keys': {'really': 'yeah!'}}

assert d == {'a': 1,'b': {'b1': 'c1'}, 'kw1': 1,'kw2': 2, 'z1': {'yyyy': {'xbb': [1, 2, 23] } },'more_keys': {'really': 'yeah!'} }
Package: d1Login
Python helper for authenticating in a DataONE environment.The d1_certificate library offers some routines to assist with authenticating for interactions with DataONE services.
Authentication requires a web browser UI, and so is not suitable for use on headless systems. The basic process is:A web browser is opened to select an identity providerCredentials are entered into the selected IDPA certificate signing request is created and token information is retieved from CILogonThe certificate is signed and moved to a consistent location.Caveats:A web browser is requiredIt is assumed that the file downloaded by the web browser is located in ${HOME}/DownloadsThe generated certificate is placed into ${HOME}/.dataone/certificatesThe subject mapping and group info in the certificate is static. Be aware that the certificate will need to be
regenerated if your user id mapping or group membership needs to change.InstallationRelease install:pip install -U d1loginDevelopment install:git clone
cd d1Login
pip install -U -e .ExampleThe commandline app will open a web browser at the appropriate login URL. After authenticating, the browser will
download a.jnlpfile. This should be placed in ~/Downloads. The script will be waiting (upto 60 seconds) for the.jnlpand once available, will process the file and request the certificate.Commandline:d1login
<<browser opens, download jnlp file>>
Certificate downloaded to: /Users/vieglais/.dataone/certificates/x509up_u501As a library:>>> import d1_certificate
>>> service = d1_certificate.LOGIN_SERVICE['dev']
>>> certpath = d1_certificate.login(overwrite=True, service=service)
# Browser window opens for authentication

>>> print certpath
/Users/vieglais/.dataone/certificates/x509up_u501

>>> d1_certificate.getSubjectFromCertFile( certpath )
{'not_after': '20151216225323Z',
 'not_before': '20151216044823Z',
 'status': True,
 'subject': 'CN=Dave Vieglais A34511,O=Google,C=US,DC=cilogon,DC=org',
 'subject_info': None}On OS X, the certificate can then be imported into the keychain for browser interactions with nodes in the authenticated
environment. For example:CERT=/Users/vieglais/.dataone/certificates/x509up_u501
openssl x509 -outform der -in ${CERT} -out "${CERT}.der"
security add-certificates "${CERT}.der"Now open a browser (chrome or safari, firefox uses it’s own cert management independent of keychain)
and visit the URL:https://cn-dev.test.dataone.org/cn/v2/diag/subjectYou should see your credentials in the xml response.On Yosemite, you can no longer use .pem format certificates to authenticate using curl
[See:http://curl.haxx.se/mail/archive-2014-10/0053.html]. Instead, convert to a .p12 format certificate and use that
instead. Note of course, that entering your password on the command line like this is a security risk since it will
appear in bash history, log files, and so forth. Example:CERT=/Users/vieglais/.dataone/certificates/x509up_u501
openssl pkcs12 -export -in ${CERT} -out ${CERT}.p12 -passout pass:Some_Password
curl -E ${CERT}.p12:Some_Password "https://cn.dataone.org/cn/v2/diag/subject"
Package: d22
d22d22 is a project inspired by the Avrae ownedd20project made also in python. It was made in order to provide a better sense of customisability to another project:d22 Dice Roller App. d22 differs in quite a few ways from d20 in terms of run time and features, however one of which is that d22 includes the use of assignment to an expression. This is something I  thought was paramount in deciding to implement my own language instead of using pre-made resources because it allows users to reference in-app names. Other key features are as below.Key FeaturesDoesn't require complex set-upJSON to AST convertibilitySelf-described lambda expressionsAssignment operationsHosted onapi.libnexus.comInstallationMade in python 3.9Supported by python 3.8+python3 -m pip install -U d22Quick-start example>>>importd22>>>result,error=d22.roll('4d6')>>>iferror:...print(error.printable())...elif:...print(result.evalprintable())...print(result.plainprintable())'<Sequence: (<Number: 1>, <Number: 3>, <Number: 3>, <Number: 5>)> = <Sequence: (<Number: 1>, <Number: 3>, <Number: 3>, <Number: 5>)>''4d6 = 1, 3, 3, 5'GrammarTutorials
Package: d2a
RequirementsPython: 3.5 or later.Tested with 3.6, 3.9Django: 2.x, 3.xTested with 2.2.9, 3.0.1, 3.1.1SQLAlchemy: 1.1 or later.Tested with 1.1.0, 1.4.12 STEPS TO USEInstallation$pipinstalld2a-UAdd d2a to settings.INSTALLED_APPS.INSTALLED_APPS=['django.contrib.admin','django.contrib.auth','django.contrib.contenttypes','django.contrib.sessions','django.contrib.messages','django.contrib.staticfiles',# :# :'d2a',]Code generation$./manage.pysqla_codegenLinkPyPISee more details onwalkframe docsHistory
Package: d2api
d2apiIntroductionPython 3 wrapper and parser for interacting with Valve's Dota 2 WebAPI.DocumentationThis project is still growing, with additonal parsing, tests,  documentation and examples.InstallationInstall using pip (recommended)Install from pip using:$pipinstalld2apiClone from githubDownload the latest build and install using:$gitclonehttps://github.com/whoophee/d2api/
$cdd2api/
$pythonsetup.pyinstallGetting StartedFirst of all, you need an API key fromSteam. Once that's done, you can initialize the wrapper in one of two ways.Initialize using Environment VariableSet the environment variableD2_API_KEYto the API key you just generated, and then initialize your wrapper using,api=d2api.APIWrapper()Initialize inlineYou can also initialize the wrapper inline using,# This takes priority over the environment variableapi=d2api.APIWrapper(api_key='your api key')You can find further use cases and exampleshere.DocumentationDocumentation is available athttp://d2api.readthedocs.org/
Package: d2b-asl
d2b-aslPlugin for the d2b package to handle ASL dataInstallationpipinstalld2b-aslUser GuideThis package adds support for theaslContextfield in the description objects located in thed2bconfig files. This field should be an array of strings, where each string is a volume type (as defined in theBIDS specification here). Specifically, this array should have the same number of entries as the described ASL acquisition has volumes (if there are 109 volumes in the acquisition which this description is describing, thenaslContextshould be an array of length 109).For example, a config file describing an ASL acquisition might looks something like:{"descriptions":[{"dataType":"perf","modalityLabel":"asl","criteria":{"ProtocolName":"ep2d_pasl","MagneticFieldStrength":3,"MRAcquisitionType":"2D","ImageType":["ORIGINAL","PRIMARY","ASL","NONE","ND","NORM","FILTERED","MOSAIC"]},"sidecarChanges":{"ArterialSpinLabelingType":"PASL","PostLabelingDelay":1.8,"BackgroundSuppression":false,"M0Type":"Included","TotalAcquiredPairs":54,"AcquisitionVoxelSize":[3.5,3.5,4.5],"BolusCutOffFlag":true,"BolusCutOffDelayTime":0.7,"BolusCutOffTechnique":"Q2TIPS","PASLType":"PICORE"},"aslContext":["m0scan","control","label","control","label","control","label",// full array omitted for readability ..."control","label"]}]}
Package: d2b-compile
d2b-compilecompile-dcm2bids-config plugin for the d2b package.Installationpipinstalld2b-compileUsageAfter installation thed2b runcommand should have additionalcompile-subcommand:$ d2b --help
usage: d2b [-h] [-v] {run,scaffold,compile} ...

d2b - Organize data in the BIDS format

positional arguments:
  {run,scaffold,compile}

optional arguments:
  -h, --help            show this help message and exit
  -v, --version         show program's version number and exit$ d2b compile --help
usage: d2b compile [-h] [-o OUT_FILE] in_file [in_file ...]

positional arguments:
  in_file               The JSON config files to combine

optional arguments:
  -h, --help            show this help message and exit
  -o OUT_FILE, --out-file OUT_FILE
                        The file to write the combined config file to. If not specified outputs are written to stdout.Thed2b compilesubcommand is a thin wrapper aroundcompile-dcm2bids-config.
Package: d2b-dcm2niix
d2b-dcm2niixDcm2niix plugin for the d2b packageInstallationpipinstalld2b-dcm2niixUsageAfter installation thed2b runcommand should have additionaldcm2niix-specific flags:$ d2b run --help
usage: d2b run [-h] -c CONFIG_FILE -p PARTICIPANT -o OUT_DIR [-s SESSION] [-l {DEBUG,INFO,WARNING,ERROR,CRITICAL}] [--no-dcm2niix | --dcm2niix | --force-dcm2niix] in_dir [in_dir ...]

Organize data in the BIDS format

positional arguments:
  in_dir                Directory(ies) containing files to organize

required arguments:
  -c CONFIG_FILE, --config CONFIG_FILE
                        JSON configuration file (see example/config.json)
  -p PARTICIPANT, --participant PARTICIPANT
                        Participant ID
  -o OUT_DIR, --out-dir OUT_DIR
                        Output BIDS directory
  --no-dcm2niix         Don't run dcm2niix on the input directories. (This is the default)
  --dcm2niix            Run dcm2niix on each of the input directories before organization code executes. dcm2niix execution will be skipped for directories for which converted results from a previous run are found.
  --force-dcm2niix      Run dcm2niix on each of the input directories before organization code executes. Previous dcm2niix results will be overwritten

optional arguments:
  -s SESSION, --session SESSION
                        Session ID
  -l {DEBUG,INFO,WARNING,ERROR,CRITICAL}, --log-level {DEBUG,INFO,WARNING,ERROR,CRITICAL}
                        Set logging levelSpecifically, the following new (mutually exclusive) options are available:--no-dcm2niix: This is the default behaviour (i.e. the behaviour of thed2b runcommand if none of the dcm2niix flags are set)--dcm2niix: This will try to rundcm2niixon (copies of) each of the input directories prior to proceeding with BIDS-ification.NOTE:If any NIfTI files are found from a previousd2b run --dcm2niix ...run, then dcm2niix will not be invoked on that (copy of that) specific input directory.--force-dcm2niix: This will rundcm2niixon (copies of) each of the input directoriesalways, regardless of files from previousd2b runruns.Also, there should be a new subcommandd2b dcm2niixavailable:$ d2b dcm2niix --help
usage: d2b dcm2niix [-h] in_dir [in_dir ...] out_dir

Run dcm2niix with the options used by d2b

positional arguments:
  in_dir      DICOM directory(ies)
  out_dir     Output BIDS directory

optional arguments:
  -h, --help  show this help message and exitThis command is the equivalent ofdcm2bids'sdcm2bids_helpercommand. In particular it's serves as a way to run dcm2niix in the exact same way thatd2b run --[force-]dcm2niixwould run the command (i.e. potentially useful to see what the resulting sidecars/filenames would look like).
Package: d2b-yaml
d2b-aslPlugin for the d2b package to handle configuration files written in YAML.Installationpipinstalld2b-yamlUser GuideThis package adds support for configuration files written in YAML. Once this package is installed one can then run something like:d2brun\--config="d2b-config.yaml"\--participant="01"\--session="001"--out-dir="my/bids/dataset/dir/"\"my/input/dir/"Seeexamples/d2b-config.yaml. The Schema for YAML configuration files is exactly the same as for JSON configuration files (JSON Schema)
Package: d2-dome
d2-domeDome from Declarative Data Inc. contains the required modules to interactive with Dome Data Product and management IntentsGetting StartedFollow the steps described below to use this modulePrerequisitespython3pandasrequestsUsageInstallationpip install d2-domeImport and Initialize a Dome Productfrom dome import Product
my_product = Product(productId="12345678")Get Product and Attribute Infoproduct_df, attributes_df = my_product.info()Get Management Intents that govern the lifecycle of a Productproduct_intents = my_product.intents()Get Series Members (Partition Keys and Values) of the Productproduct_series_members_df = my_product.series_members()Read Product DataThe read operation takes following optional parameters+columns: Optional[List[str | dict]] - A list of all columns to be read. The List can contain a string with the column name or a dict with column name as the key and grouping function to be applied as value
+where: Optional[str] - A string containing a filter expression to be added. Note: The expression should not include the where key word
+group_by: Optional[List[str]] - A list of column names for grouping the results
+order_by: Optional[List[str]] - A list of column names for grouping the results
+limit: Optional[int] - A limit to number of records to be returnedHere are few examplesRead all product dataproduct_read_df = my_product.read()Read only 10 rows of my productproduct_read_df = my_product.read(limit=10)Read only 2 columns with a where condition and limit to 10 rowsproduct_read_df = my_product.read(columns=["col1","col2"], where="col3 = 'col3_value'", limit=10)Read with results groupedproduct_read_df = my_product.read(columns=["col1",{"col2":"sum"}], where="col3 = 'col3_value'", group_by=["col1"], order_by=["col1"], limit=10)AuthorsBhavin DaveSupportPlease reach out toinfo@declarativedata.com
Package: d2f2
d2f2 2.1.3d2f2is a tool written in Python to convert image folders into files.InstallationYou can install (and update)d2f2fromPyPIvia the command linepip install d2f2 -Uor use one of the standalone versions (see below).UsageOperation modesd2f2offers two modes of operation: "single" and "batch".Single modeThe standard mode, converts each given directory into a file.d2f2 /a/path /another/path ...Batch modeUseful for converting big batches of folders, this mode converts each subdirectory within the given directories into a file. To use it, add the-b/--batchoption to the command:d2f2 -b /a/path /another/path ...Output formatBy default,d2f2saves files in the PDF format. If you want to use another supported format, use the-f/--formatoption:d2f2 /a/path ... -f FORMATCurrently, there are 2 supported formats (with more to be added in the future). Use the appropriate format as the FORMAT parameter:[PDF] - Portable Document Format (default)[CBZ] - Comic Book Format, ZIP-compressedOutput pathBy standard,d2f2saves files to the current directory. If you want another output path, use the-o/--outputoption:d2f2 /a/path ... -o /an/output/pathSorting modeBy default,d2f2sorts the images in alphanumeric, ascending order (A-Z). If you want to use another sorting mode you can specify one by using the-s/--sortoption:d2f2 /a/path ... -s MODECurrently, there are 6 sorting modes available. Use the corresponding number from the following list as the MODE parameter:[ 1] Alphanumeric, ascending (default)[-1] Alphanumeric, descending[ 2] Last time modified, oldest first[-2] Last time modified, newest first[ 3] Time of creation / metadata change, oldest first[-3] Time of creation / metadata change, newest firstShelld2f2offers an interactive shell including all functions of the normald2f2CLI tool.Standalone versions for the shell are available for Windows and Linux (seeReleases)You can also start the shell from the command line:d2f2 --shellTODOMore output formats (EPUB, MOBI)Custom order for imagesModify names of output filesStandalone GUI clientDisclaimerThis tool uses thePyMuPDFlibrary, which provides the core functionality of inserting images into PDF files. According to its licensing terms, this project is released under the AGPLv3 license (for more information, see LICENSE)
Package: d2lib
d2lib is a tool for retrieving information from Diablo 2 data files.
These files contain info about the character, items and their properties.Supported files:.d2s - Diablo 2 save files;.d2x - PlugY personal stash files;.sss - PlugY shared stash files.InstallationPrerequisitesPython 3.6+You can install d2lib using pip:pip install d2libUsagefromd2lib.filesimportD2SFile,D2XFile,SSSFiled2s_file=D2SFile('tests/data/test_d2s.d2s')d2x_file=D2XFile('tests/data/test_d2x.d2x')sss_file=SSSFile('tests/data/test_sss.sss')# Character attributes.print(d2s_file.char_class)print(d2s_file.char_name)print(d2s_file.char_level)print(d2s_file.is_died)print(d2s_file.last_played)print(d2s_file.attributes)print(d2s_file.skills)# Get all unique items.foritemind2s_file.items:ifitem.is_unique:print(item.level)print(item.name)print(item.base_name)print(item.magic_attrs)# or for stash filesforpageind2x_file.stash:# there may also be a SSSFile instanceforiteminpage['items']:ifitem.is_unique:print(item.level)print(item.name)print(item.base_name)print(item.magic_attrs)Acknowledgmentsnokka/d2ssqueek502/d2itemreader
Package: d2lmf
MotivationIt’s frustrating dealing with the zip files full of assignment
submissions that you get from D2L.Merging all of a student’s submissions into a single folder is
tedious.Navigating submissions on the command line sucks, because each
directory name starts with a long number.Extracting all the zip files, tar archives, and 7z archives that
students submit adds a needless extra step to marking.I’ve found this tool useful for eliminating those annoyances, and I hope
you will too.How to UseThis is the most common command I use:d2lmfextract-R"Assignment 1 Download Oct 11, 2015 803 PM.zip"A1/T01It extracts the submissions from the zip folder into the directoryA1/T01. The-Roption makes it run all the recommended cleanup
actions on the submissions, and is equivalent to using-x,-j,-cand-m.The-xspecifies that we want to extract any zip, rar, tar, or 7z
archives that students submitted. The-jdeletes ‘junk’ like.DS_Store. The-ccollapses needlessly nested directories.
Finally, the-mmerges all submitted files into a single directory
for each student.On Windows, you may need to invoke d2lmf as a Python module, like so:python-md2lmfextract-R"Assignment 1 Download Oct 11, 2015 803 PM.zip"A1/T01How to InstallUbuntusudoapt-getinstallpython-pipsudopipinstalld2lmfOSXcurlhttps://bootstrap.pypa.io/get-pip.py>get-pip.pysudopythonget-pip.pysudopipinstalld2lmfWindowsFirst, download and install Python fromhttps://www.python.org/downloads/Then, install d2lmf with the command below:python-mpipinstalld2lmfDependenciesThe extraction of rar and 7z archives depends on external tools. If you
do not have a rar or 7z utility installed, those archives will be
skipped.On Windows, I suggest installing7-Zip. On
Ubuntu, p7zip is the equivalent, and it can be installed withsudoapt-getinstallp7zip-full. p7zip is also available for OSX,
and can be installed fromhomebrewwithbrew install p7zip.
Package: d2lvalence
This is a re-release of thed2lvalencePython package originally released by
Viktor Haag and the D2L Extensibility product development team. This re-release
is version 1.2.2, released by that team in 2016. Although this was originally only
tested up to Python 3.5, our team has tested this with Python releases up to
3.10.13 without issue.Desire2Learn Client Library for PythonThe Python library divides functionality into a number of modules. The primary
module helps with authentication. Several supporting modules can assist with
making calls in several areas of the Valence API.Authentication. Thed2lvalence.authmodule provides assistance for
the authentication needed to invoke Valence APIs. You use the module’s functions
(and perhaps also classes) to create acalling user context <d2lvalence.auth.D2LUserContext>object that
you can then employ in conjunction with the Requests package as an
authentication helper.InstallationYou can find the source for our Python client library SDK in two locations:Our ownPython client GitHub repository.On the PyPipackage index repository,
so you can install it as a package with pip or easy_install.Dependencies. In order to use the Python client library SDK, you’ll need to
first ensure you have a working Python development environment:Python 3 (the reference environment uses Python 3.5), or Python 2.7 (via the
use of the future library).TheRequests Python packagegets included in ourauth <d2lvalence.auth>module so that you can use a
calling user context object as an authentication helper for Requests.Thepython-futurelibrary gets used
to provide Python 2.7 compatibility.TheBottle Python packageif you want to
use the samples available in conjunction with this client library (not a
dependency for the client library itself).
Package: d2m.rendersource
First take on making the zope.app.render classes available from Grok templates.RestructuredText: template files with ‘.rst’ extensionrenders a complete HTML page, including embedded stylesheet (default)
or with a configurable external stylesheetChanges0.5+ changed the package namespace from d2m.rendersource tomegrok.rendersource0.4 support for include/raw/csv-table directives,input/output-encoding can be configured in the view.namespace method,
added functional tests0.3 added template reloading when in developer mode,changed configure.zcml to support autoinclude0.2 added missing configure.zcml,added configurable styleheet (settings_overrides)