Saravanan666/pypi-org huggingface dataset:
Package: pycsn
pycsnPython package supporting cds for table definitions in the first place. The data type is adictand therefore using csn/json as the primary formatn from which a cds-document can be created.Use cases:Commandline: creating csn-file from csv-file that can be then adjustedUse package for creating a csn-file in a python script, e.g.Create csn from pd.DataFrame with index as primary keysAdd annotationsCommandlineusage:pycsn[-h][filename][csn]Createscsn-filefrompandasDataFrame.

positionalarguments:filenameDataFilename(csv)orfolder(delta)csncsn-file(optional)options:-h,--helpshowthishelpmessageandexitTable of ContentsInstallationLicenseInstallationpip install pycsnFor testingInstall cdsInstall the cds cli tool "cds-dk"npmadd-g@sap/cds-dkLocal DatabaseBecause the final destination of a table is HANA, you should test if the resulting sql-statement (CREATE TABLE) works. sqlite is recommended by SAP CAP.For MacOs:brewinstallsqliteTestingpyscnis using adicta its primary data format.Example Datatable : store
columns :
transaction_id:
store_id:Licensepycsnis distributed under the terms of theMITlicense.
Package: pycsoap
# pycsoap## example```from ase.io import readfrom pycsoap.soaplite import SOAPgb1 =read('/Users/andrewhuynguyen/Desktop/gb0011039001.xyz')soap_desc = SOAP(atomic_numbers=[26], rcut=5, nmax=9, lmax=9)input_soap=soap_desc.create(gb1)input_soap````input_soap` will return a matrix MxN (M is the number of atoms in the cell and N is based on rcut, nmax, and lmax).
Package: pycsp
PyCSP is a CSP library for Python that implements core CSP
functionality with some extensions from pi-calculus.Providing:Synchronous communicationBuffered channelsMultiple process types such as, greenlets, threads, processes and remote processesBoth input and output guards supported in external choice (Alts)A single any-to-any channel typeMobile channel-endsRetire and poison signals for shutting down networks nicelyA channel which can communicate using inter-process communication as well as sockets.A PyCSP providing local and distributed communication using only standard python modules bundled with CPythonNAT traversalTracing PyCSP executions to a log file, for later visualisationSeehttps://github.com/runefriborg/pycsp/wikifor more information.
Package: pycsphere
Pycsou-sphereis an extension module of the Python 3 packagePycsoufor solving linear inverse problems on the sphere. The extension offers implementations of spherical zonalconvolutionoperators as well as the spherical harmonic and Fourier-Legendre transforms (all compatible with Pycsou’s interface for linear operators). It also provides numerical routines for computing the Green kernels of common spherical pseudo-differential operators and generating spherical meshes/point sets.This module heavily relies and follows similar conventions as thehealpypackage for spherical signal processing with Python.ContentThe package, namedpycsphere,  is organised as follows:The subpackagepycsphere.linopimplements the following common spherical linear operators:Convolution/pooling operators,Spherical transforms and their inverses,Finite-difference spherical differential operators.The subpackagepycsphere.meshprovides routines for generating spherical meshes.The subpackagepycsphere.greenprovides numerical routines for computing the Green  kernels of common spherical pseudo-differential operators.InstallationPycsou-sphere requires Python 3.6 or greater. It is developed and tested on x86_64 systems running MacOS and Linux.DependenciesBefore installing Pycsou-sphere, make sure that the base packagePycsouis correctly installed on your machine.
Installation instructions for Pycsou are available atthat link.The package extra dependencies are listed in the filesrequirements.txtandrequirements-conda.txt.
It is recommended to install those extra dependencies usingMinicondaorAnaconda. This
is not just a pure stylistic choice but comes with somehiddenadvantages, such as the linking toIntel MKLlibrary (a highly optimized BLAS library created by Intel).>>condainstall--channel=conda-forge--file=requirements-conda.txtQuick InstallPycsou-sphere is also available onPypi. You can hence install it very simply via the command:>>pipinstallpycsou-sphereIf you have previously activated your conda environmentpipwill install Pycsou in said environment.
Otherwise it will install it in yourbaseenvironment together with the various dependencies obtained from the filerequirements.txt.Developer InstallIt is also possible to install Pycsou-sphere from the source for developers:>>gitclonehttps://github.com/matthieumeo/pycsou-sphere>>cd<repository_dir>/>>pipinstall-e.The package documentation can be generated with:>>condainstallsphinx=='2.1.*'\sphinx_rtd_theme=='0.4.*'>>python3setup.pybuild_sphinxYou can verify that the installation was successful by running the package doctests:>>python3test.pyCiteFor citing this package, please see:http://doi.org/10.5281/zenodo.4486431
Package: pycspr
Casper Python SDKPython library for interacting with a CSPR node.Installationpip3 install pycsprUsageHow To: Query a node ?How To: Transfer funds between 2 accounts ?How To: Delegate funds to a validator ?How To: Undelegate funds from a validator ?How To: Stake funds as a validator ?How To: Unstake funds as a validator ?How To: Install a smart contract ?How To: Invoke a smart contract ?How To: Query a smart contract ?How To: Speculatively execute a deploy ?How To: Hash data ?How To: Create Key Pairs ?How To: Apply a checksum ?How To: Await Events  ?How To: Consume Events  ?DevelopmentPre-Requisites1. Setup Local CCTL Network.2. Install poetry.Install SDKcd YOUR_WORKING_DIRECTORY
git clone https://github.com/casper-network/casper-python-sdk.git
cd casper-python-sdk
poetry installTestingImportant Environment VariablesMandatoryCCTLpath to local clone of CCTL repoOptionalPYCSPR_TEST_NODE_HOSThost of a test nodedefault =  localhostPYCSPR_TEST_NODE_PORT_RESTport of rest server exposed by test nodedefault =  14101PYCSPR_TEST_NODE_PORT_RPCport of json-rpc server exposed by test nodedefault =  11101PYCSPR_TEST_NODE_PORT_SSEport of sse server exposed by test nodedefault =  18101PYCSPR_TEST_NODE_PORT_SPEC_EXECport of speculative execution server exposed by test nodedefault =  25101Running Testscd YOUR_WORKING_DIRECTORY/casper-python-sdk
poetry shell
pytest ./tests [TEST-FILTER]
Package: pycsse
http://github.com/idlesign/pycsseWhat’s thatpyCSSe is CSSe to CSS export tool in Python, able to function both as a Python module and in command line mode.RequirementsPython 2.5+About CSSeCSSe is an unofficial CSS format extension, introducing variables and class mixins
to speed up CSS writting and logically organize CSS structure.The reason for CSSe is that CSS have no such featues yet, and LESS, SASS, etc. things seem overcomplicated.CSSe format example:/* These are variables that can be used in place of property values. */
_vars {
    gap_min: 10px;
    gap_med: 15px;
    gap_max: 30px;
    /* Variable can reference another variable as long as the latter was previously defined. */
    gap: @gap_min;
}

.indent_left {
    /* Get value from variable `gap`. */
    margin-left: @gap;
}

.brand_box {
    background-color: @color_brand;
    margin-bottom: @gap_med;
    margin-top: @gap_min;
    color: @color_subtle;
}

/* One can declare additional variable as necessary. */
_vars {
    color_brand: #5f9ea0;
    color_subtle: #f0fff0;
}

/* Any block can borrow properties from other classes. */
blockquote {
    /* We borrow properties from `indent_left` class. */
    mix: indent_left;
    /* And we borrow properties from `brand_box` class. */
    mix: brand_box;
    margin-bottom: @gap_max;
}The above example is translated into the following CSS:.indent_left {
    margin-left: 10px;
}

.brand_box {
    background-color: #5f9ea0;
    margin-bottom: 15px;
    margin-top: 10px;
    color: #f0fff0;
}

blockquote {
    margin-bottom: 15px;
    margin-left: 10px;
    background-color: #5f9ea0;
    margin-top: 10px;
    color: #f0fff0;
}UsageDoimport pycsseif you want to use it as module. UseCsseParserandCssExporterclasses.Put./pycsse.py -hin command line to get help on utility usage.Cooking hintsExport CSSe frommy_csse.cssinto minified CSS file namedmy_css.css:./pycsse.py -o my_css.css my_csse.cssExport all CSSe files with .csse extension from a directory into one minified CSS:./pycsse.py -o my_css.css --source_ext .csse /home/user/web/my_css_dir/Use watch mode to export all .css files from source directory automatically:./pycsse.py -o my_auto_css.css --watch /home/user/web/my_css_dir/
Package: pycss-lem
It is an open-source program written in Python for 2D slope stability analysis of circular surfaces by the limit equilibrium method (Fellenius and Bishop methods).Downloading the programTo installpyCSS v0.1.0from PyPI, run this command in your terminal:pip install pycss-lemAlso, you can clone the original repo directory (release v0.0.9) using git:git clone https://github.com/eamontoyaa/pyCSS/ --branch v0.0.9or directly use the download options from GitHub.Installing dependenciesThe program has been tested in Python ≥3.6.  It is suggested to create a virtual environment to use the program.From release v0.1.0, the program is expected to install its dependencies automatically. If this does not happen, please follow the instructions as for previous releases:Download therequirements.txtfile. In the same directory, type and execute the following line in your terminal:python3 -m pip install -r requirements.txtUsageRelease v0.1.0+You can run the program by editing thescript_template.pyfile located in the./examples/directory of the installation folder.
Use the examples located in the same folder as an input guide.
Then, save the script wherever you need it to be saved, and run it by typing the following line from the terminal:python3 script_template.pyNote:the graphical user interface is not yet available from release v0.1.0.Release v0.0.9You can run the program via GUI by typing the following line in the root directory:python3 pyCSS.pyOr editing thefinalModule.pyfile located in the root directory and running it:python3 finalModule.pyYou can test the program by runing the files in the/examplesfolder.cd examples/
python3 example01.pyIf the example runs successfully, the program will create two files. One is a graphical output of the slope and the stability analysis. The second file is a text file with a summary of the run.DocumentationPlease refer to the user manualuser manual for release v0.0.9to learn more. Currently, the manual is in Spanish, but in the future, we will translate it to English.CitationTo citepyCSSin publications, use:Suarez-Burgoa, Ludger O., and Exneyder A. Montoya-Araque. 2016.
“Programa en código abierto para el análisis bidimensional de estabilidad
de taludes por el método de equilibrio límite.” Revista de La Facultad
de Ciencias 5 (2): 88–104. <https://doi.org/10.15446/rev.fac.cienc.v5n2.59914>.A BibTeX entry for LaTeX users is:@article{SuarezBurgoa_MontoyaAraque_2016_art,doi={10.15446/rev.fac.cienc.v5n2.59914},journal={Revista de la Facultad de Ciencias},keywords={C{\'{o}}digo fuente libre,an{\'{a}}lisis de estabilidad de taludes,m{\'{e}}todo de Bishop,m{\'{e}}todo de equilibrio l{\'{i}}mite},month={jul},number={2},pages={88--104},title={{Programa en c{\'{o}}digo abierto para el an{\'{a}}lisis bidimensional de estabilidad de taludes por el m{\'{e}}todo de equilibrio l{\'{i}}mite}},volume={5},year={2016}}
Package: pycsspeechtts
pycsspeechttsPython (py) library to use Microsofts Cognitive Services Speech (csspeech) Text to Speech (tts) API.
The cryptic name is the combination of the abbrevations shown above.Usage:frompycsspeechttsimportTTSTranslatort=TTSTranslator("YOUR API KEY","westeurope")data=t.speak(text='The default voice is using Microsoft Neural Voice. When using a neural voice, synthesized speech is nearly indistinguishable from the human recordings.')withopen("file1.wav","wb")asf:f.write(data)data=t.speak('en-gb','Male','I am Max','George, Apollo','riff-16khz-16bit-mono-pcm',text='I am Max')withopen("file2.wav","wb")asf:f.write(data)You can also use custom voice by specifyingisCustom=Trueand providing acustomEndpoint:frompycsspeechttsimportTTSTranslatort=TTSTranslator("YOUR API KEY","westeurope",isCustom=True,customEndpoint=MyEndpoint)data=t.speak(language='en-gb',gender='Male',voiceType="ArchieNeural",text="This is a test for custom voice")See test.py for more samples.
Refer tohttps://docs.microsoft.com/en-us/azure/cognitive-services/speech-service/language-supportto find the valid values for language, gender, voicetype and output formats.
Package: py-css-styleguide
This is a Python library to build a design styleguide from a CSS manifest file.Opposed to many styleguide builders this does not require to documentate styles from
your stylesheets. Instead it is based on Sass variables to build a map of your style
rules.FeaturesPython interface to load a CSS manifest and return it as a Python dictionnary or
JSON data;(Optional) Tiny Sass mixin library to write CSS manifest from your Sass project
settings;(Optional) Django mixin and view to load manifest from your project or application;LinksRead the documentation onRead the docs;Download itsPyPi package;Clone it on itsGithub repository;DependenciesPython>=3.8;tinycss2>=1.1.0;Click>=8.0;CreditsLogo vector and icon bySVG Repo.
Package: pycsvdb
Read csv and insert into DBRequirementsPython 3.xhashlibpandassqlalchemyshelvenumpyInstallation$ pip install pycsvdbExamplefrom pycsvdb import CsvManage

CsvManage(db_config_file="config.ini", file_name="filename.csv", primary_key="id", table_name="table_name")Confi.ini format[DB]


sqlalchemy.url = postgresql://postgres:password@localhost:5432/postgres

stage_schema = stage_table

prod_schema = prod_table
Package: pycsvify
PyCSVifyA Python library that allows easy conversion from CSV to Dict and back!UseparseCSVfile(location, seperator)to convert a CSV file to a dictionaryUseparseCSV(csvString, itemSeperator, lineSeperator)to convert a CSV string to a dictionaryUseexportCSV(dictionary, itemSeperator, lineSeperator)to convert a dictionary to a CSV string
Package: pycsvjson
A command-line utility to convert CSV files to JSON.InstallationRequires:Python 3You should really consider using virtual environments when installing any Python software. Seehttp://docs.python-guide.org/en/latest/dev/virtualenvs/#virtualenvironments-reffor more information on virtual environments.To use virtual environments with pycsvjson, do something like:` pip install virtualenv virtualenv-p$(which python3) .ve source .ve/bin/activate `To install this package:pip install pycsvjsonQuickstartpycsvjson csvfile mappingfile –output outfileFor pretty, human-readable versions of JSON, use the–prettyoption:pycsvjson file.csv mapping.json –output outfile.json –prettyFor extended options:pycsvjson –helpFor more information on what a mapping file is, seehttps://github.com/pudo/jsonmappingStatusThis software should be considered Alpha.LicenseThis project is released under the MIT License.
Package: pycsvschema
PyPI Page:https://pypi.python.org/pypi/pycsvschemaGithub Page:https://github.com/crowdskout/PyCSVSchemaIntroductionPyCSVSchema is an implementation ofCSV Schemain Python.This project is under heavy development.>>>frompycsvschema.checkerimportValidator>>>>>># demo.csv:...# id,name,value...# 1,Ann,"5"...# 2,Ben,"10"...# 3,Tom,"14"...>>>>>>schema={...'fields':[...{...'name':'value',...'type':'number',...'multipleOf':5...}...]...}>>>>>>v=Validator(filename='demo.csv',schema=schema)>>>v.validate()Traceback(mostrecentcalllast):...<ValidationError:'Value 14.0 is not multiple of 5';column:value;row:3>InstallationpipinstallpycsvschemaLicensePyCSVSchema uses the MIT license, seeLICENSEfile for the details.
Package: pycsvsql
# Overviewpycsvsql is a csv sql convertor.# Setup## RequirementsPython 3.6+## InstallationInstall pycsvsql with pip:`sh $ pip install pycsvsql `or directly from the source code:`sh $ git clonehttps://github.com/gzxultra/pycsvsql.git$ cd pycsvsql $ python setup.py install `
Package: py-csv-xls
py-csv-xlsConverter from csv format to xlsInstallationpipinstallpy-csv-xlsExamplefrompy_csv_xlsimportCSVSniffer,ExcelWorker,PyCsvXlsExceptionfile_lines=CSVSniffer(main_path="/abs/path/to/ur/csv/or/dir",).get_dir_files_with_lines()ExcelWorker(workbook_name="/abs/path/to/ur/xl/without/extension",workbook_extension=".xls",want_cleared=True,).fill_workbook(all_data=file_lines)
Package: pycsvy
CSVY for PythonCSV is a popular format for storing tabular data used in many disciplines. Metadata
concerning the contents of the file is often included in the header, but it rarely
follows a format that is machine readable - sometimes is not even human readable! In
some cases, such information is provided in a separate file, which is not ideal as it is
easy for data and metadata to get separated.CSVY is a small Python package to handle CSV files in which the metadata in the header
is formatted in YAML. It supports reading/writing tabular data contained in numpy
arrays, pandas DataFrames and nested lists, as well as metadata using a standard python
dictionary. Ultimately, it aims to incorporate information about theCSV
dialectused and aTable
Schemaspecifying the contents of each
column to aid the reading and interpretation of the data.Instalation'pycsvy' is available in PyPI therefore its installation is as easy as:pipinstallpycsvyIn order to support reading intonumpyarrays or intopandasDataFrames, you will
need to install those two packages, too.UsageIn the simplest case, to save some data contained indataand some metadata contained
in ametadatadictionary into a CSVY fileimportant_data.csv(the extension is not
relevant), just do the following:importcsvycsvy.write("important_data.csv",data,metadata)The resulting file will have the YAML-formatted header in between---markers with,
optionally, a comment character starting each header line. It could look something like
the following:---
name: my-dataset
title: Example file of csvy
description: Show a csvy sample file.
encoding: utf-8
schema:
  fields:
  - name: Date
    type: object
  - name: WTI
    type: number
---
Date,WTI
1986-01-02,25.56
1986-01-03,26.00
1986-01-06,26.53
1986-01-07,25.85
1986-01-08,25.87For reading the information back:importcsvy# To read into a numpy arraydata,metadata=csvy.read_to_array("important_data.csv")# To read into a pandas DataFramedata,metadata=csvy.read_to_dataframe("important_data.csv")The appropriate writer/reader will be selected based on the type ofdata:numpy array:np.savetxtandnp.loadtxtpandas DataFrame:pd.DataFrame.to_csvandpd.read_csvnested lists:'csv.writerandcsv.readerOptions can be passed to the tabular data writer/reader by setting thecsv_optionsdictionary. Likewise you can set theyaml_optionsdictionary with whatever options you
want to pass toyaml.safe_loadandyaml.safe_dumpfunctions, reading/writing the
YAML-formatted header, respectively.Finally, you can control the character(s) used to indicate comments by setting thecommentkeyword when writing a file. By default, there is no character (""). During reading, the comment character is found atomatically.Contributors ✨Thanks goes to these wonderful people (emoji key):Diego Alonso Álvarez🚇🤔🚧⚠️🐛💻Alex Dewar🤔⚠️💻Adrian D'Alessandro🐛💻📖This project follows theall-contributorsspecification. Contributions of any kind welcome!
Package: pycsw
pycsw is an OGC CSW server implementation written in Python.pycsw fully implements the OpenGIS Catalogue Service Implementation
Specification (Catalogue Service for the Web). Initial development started in
2010 (more formally announced in 2011). The project is certified OGC
Compliant, and is an OGC Reference Implementation.  Since 2015, pycsw is an
official OSGeo Project.pycsw allows for the publishing and discovery of geospatial metadata via
numerous APIs (CSW 2/CSW 3, OpenSearch, OAI-PMH, SRU). Existing repositories
of geospatial metadata can also be exposed, providing a standards-based
metadata and catalogue component of spatial data infrastructures.pycsw is Open Source, released under an MIT license, and runs on all major
platforms (Windows, Linux, Mac OS X).Please read the docs athttps://pycsw.org/docsfor more information.
Package: pycsw-rpi
PyCSW RPIpycsw-rpiMonkey patchedpycswfor Slovak national catalogue service.Checkoriginalpycswdocumentationfor more details.SetupUse exactly like originalpycswInstallpipinstall--userpycsw-rpiCreate configuration fileConfiguration file is not distributed with package.Sample configuration can be downloaded from<<url>>Administrative command (CLI)pycsw_rpi-adminscript is installed with package in$PATH, this script is replacement for originalpycsw-admin.pyscript supporting modified beahaviour and can be used exactly like original one.Create databasepycsw_rpi-admin-csetup_db-f<<pconfiguration_file>>Load recordspycsw_rpi-admin-cload_records-f<<pconfiguration_file>> -p<<path_to_records_directory>>Checkoriginal documentationforpycsw-admin.pyadministrative command.Run "dev" self contained (toy) serverpython-mpycsw_rpi.wsgiDeploy as WSGI applicationpycsw_rpi.wsgimodule contains WSGIapplicationobject (function) ready to be deployed with WSGI server (e.g.gunicorn,uwsgi). No WSGI server is installed with this package as dependecy.To deploy withgunicorn:# `gunicorn` package need to installed separatelypipinstall--usergunicorn
gunicornpycsw_rpi.wsgi:applicationModifications implemented (via monkey patches) to originalpycswAdded queryables to APISO plugin:rpi:OrganizationUUIDrpi:IsViewablerpi:IsSearchableContributions
Package: pycsync
Sync pictures between filesystem and FlickrInstallThis uses thepython_flickr_api.To install latest:pip install pycsyncUsageFirst oauth needs to be setup for the application:pycsync -a

Please visit to get an verifier code:
---------------------------------
http://www.flickr.com/services/oauth/authorize?oauth_token=<token>&perms=write
---------------------------------
Please input the verifier code here:Then copy the link to a browser. After authorizing pycsync, the browser should
display something like:<rsp stat="ok">
  <method>flickr.test.echo</method>
  <api_key>key</api_key>
  <oauth_token>token</oauth_token>
  <oauth_verifier>verifer</oauth_verifier>
</rsp>Wherekeyis pycsync’s api key,tokenis the oauth token from above,
andverifieris the verifier key for further authentication. Copy theverifierand input it to pycsync.NOTE:pycsync can either be run from the sync directory or the directory
can be specified with the-poption.Now to sync simply run:pycsyncLimitationsFlickr stores photos in albums. There is no concept of a sub-album. Thus
this requires a flat file structure for the local files. The file system
layout must contain one level of directories with files in them. The
directories will be mapped to Albums. Any subdirectories will be ignored.
Also any top-level files will be ignored.
Package: pyctem
PyCTEM - A Python based toolset for computational S/TEMPyCTEM- short forPython-based toolset forcomputational (scanning-)
transmission electron microscopy (TEM).
Under the term computational S/TEM we understand the computer-based part of transmission
electron microscopy, meaning scattering simulations, data evaluations as well
as data visualization.The core ofPyCTEMis a Python library, which provides functions
and classes allowing a fine-grained control over the individual steps of
these use cases. On top of this library it features several high level Python entry points as well as
command line tools.ThePyCTEMpackage is currently under development. It will eventually feature the
full functionality of the internal Python toolset developed over the
last decade for computational TEM at the Technische Universität Berlin.