Saravanan666/pypi-org huggingface dataset:
Package: cubicweb-tsfacets
SummaryThis cube implements facets using postgresql text search vectors.What does this cube offer ?This cube defines a new CubicWeb AppObject registry:tsfacets.
The base class iscubicweb_tsfacets.views.TSFacets; it provides
three methods allowing to recover information to use facets in
a CubicWeb application:get_facets_values_with_count, which recovers all available facets
with how many target entities it filters for each value;get_target_entities_count, which counts target entities taking into
account the selected facets and possibly a RQL request to restrict
results;get_target_entities_rset, which builds a CubicWeb ResultSet taking
into account the selected facets and possibly a RQL request to restrict
results.How to use it ?For each group of facets, you have to define a child class ofcubicweb_tsfacets.views.TSFacets. Then, you have to complete
the following attributes:key_names_to_rql_definition: a dictionary linking each facet key
with a RQLRequestFacetDef object. A facet key must only contain
characters, no space, no ".", no "_", etc.
This object represents a RQL request with the information of if we
need a mapping table for the value or not. We need a mapping if we
want to index string with space or other characters like "'";text_search_indexation: a RQL request returning a list of tuples:
(target entity eid, text to index for full text search). This
attribute is optional, and is only used if you want to add
text search to your result list. Note: this feature will be added in
an upcoming version;target_etypes: which entity types are targeted by your facet search;table_name: the name of the specific postgresql table.Example of implementation:In this example, we want to add facets toPerformanceentities.
These facets will be the city, country and theater of the representation,
the date of the representation and the director.fromcubicweb_tsfacets.viewsimportTSFacets,RQLRequestFacetDefclassPerformanceTSFacets(TSFacets):__regid__="performance_tsfacets"table_name="performance_tsfacets"key_names_to_rql_definition={"city":RQLRequestFacetDef("Any X, R Where X representation_city R",True),"country":RQLRequestFacetDef("Any X, R Where X representation_country R",True),"theater":RQLRequestFacetDef("Any X, R Where X representation_theater R",True),"date":RQLRequestFacetDef("Any X, D Where X formatted_start_date D",False),"director":RQLRequestFacetDef("Any X, D Where X is Performance, C manifestation X, ""C contributor D, C role R, R code 500",False),}target_etypes={"Performance"}Thus,CubicWeb-TSFacetswill provide the methods we will need to
build our interface.
Package: cubicweb-uitest
SummaryThis cube is meant to serve both test and documentation purpose.
To achive this, the cube must ideally provide the samples of all basic cubicweb
views.SchemaThe main cube’s entity isEveryThingwith is supposed to contain all basic
cubicweb fields (e.gString,Int,DateTime,Passowrd, etc) bind whith
all basic cubicweb widgets and some widgets provided by cubes, if deemed useful.A bunch ofEveryThingis automatically created during the initialization of a
new instance.ViewsThere is two types of views :static views: a collection of typography samples such as headings,
paragraphs, lists gathered together.dinamic views: a collection of basic cubicweb views applied to EveryThing
entities. Each view must provide it’s pyhon code.InstanceCube instances must allow anonymous acces.
Package: cubicweb-varnish
SummaryThis cubes enables a purge mechanism for a cubicweb website that is
sitting behind a varnish cache.InternalsThe purge mechanism consists of sending purge commands to the
administration backend of varnish (by default
localhost:6082). Generally it is recommended to protect this
management port with a secret file which can be configured in this
cube. Multiple backends can be controlled in this manner in a
distributed setup.Out of the box, this cube will not purge any URLs. The logic of which
pages should be “purged” has to be implemented in content cubes.To configure which urls to purge, you have to implement anIVarnishAdapter, for example.. sourcecode:: pythonfrom cubes.varnish.entities import IVarnishAdapterclass BlogEntryVarnishAdapter(IVarnishAdapter):__select__ = is_instance(‘BlogEntry’)def urls_to_purge(self):return (‘/’, #frontpageself.entity.absolute_url(), #URL of blog post
‘/BlogEntry’ # list of blog entries)Debugging : cubicweb-varnish will not crash when it cannot connect to
the administrative port, it will silently log an error in the log.Docker & KubernetesWhen deploying on docker or kubernetes, you can configure this with :CW_VARNISHCLI_HOSTS=fqdn:6082,IP:PORT(csv with host:port)CW_VARNISH_SECRETS=/etc/varnish_shared_secret_token(filename with token in
it)Dependencieshttp://www.varnish-cache.org/or apt-get install varnish (for debian derived distributions)
Package: cubicweb-vcreview
SummaryThis cube provides a code review system on top of thevcsfile cube. It has
been developed with the workflow we use at Logilab in mind, based onmercurialand itsevolveextension.More information in the wdoc/ subdirectory, which is integrated in the web ui
when the cube is installed (see <your instance url>/doc/main).See alsoYou may be interested in thetrackervcswhich integratesvcsfileandvcreviewcubes into thetracker cube, allowing to link
projects to their repository, tickets to patches and revisions, etc…
Package: cubicweb-vcsfile
This cube stores the data found in a version content manager
repository. It currently works with mercurial repositories.The revision metadata (parents, author, description, etc) is stored in
entities, and thus accessible from RQL, but the files and contents are
read from the VCS on demand.Notice this cube depends on mercurial’sevolve extension. If you install
vcsfile using a Debian package, you’ll probably have to add Logilab’s backport
repository to find themercurial-evolvepackage, e.g.deb  http://download.logilab.org/backports/dists/ jessie/On other system, you’re on your own.
Package: cubicweb-vcwiki
SummaryThis is a version controlled wiki component for the CubicWeb framework.It usesMercurialas a content storage and can be edited both with your
favorite editor and the web GUI.FeaturesThe wiki web GUI usage should be pretty straightforward. It can be used to:create a page in the wiki from a yet unknown wiki’s sub-page URLedit an existing page with an optional commit messagesee a page’s history and compare versionsrevert a page to a previous version.ReStructured Text(ReST) formatted wikis benefit from CubicWeb’s powerful
ReST directives that make it easy to query the database and display the
resultset in a view (e.g.eid,rql,rql-table).Present cube also adds awikidirective, which can be used as in following
example content:This is a **formatted page content** with a link to
:wiki:`subdirectory/page`.

This displays a "subdirectory/page" text in the page, that links to URL
<current-page-url>/subdirectory/page, and which path in the Mercurial
repository is `<current-page-path>/subdirectory/page.rst`.

You can also specify a link text that is different from the page's URL
path. The URL path can be specified either from the wiki's root, like
:wiki:`/subdirectory/other:this one`, or relatively to the current page, like
:wiki:`current_page_sibling:this other one`.Wiki setupCurrently, the easiest way to setup a new wiki is through the command line:cubicweb-ctl new-vcwiki <instance-name> <wiki-name> <repo-path>This creates a ReST formatted wiki namedwiki-namefrom a pre-existing
Mercurial repository located atrepo-pathon your disk in a pre-existing
CubicWeb application instance namedinstance-name.You will need the admin user login and password to use this.An alternative is to use the web GUI, but it requires a few steps until now:The administrator must create aRepositoryentity and set itspathattribute to a valid path to a Mercurial repository (which must be created
beforehand).The administrator must add write permissions for theRepository, via
thelocalpermscube (action available at the left of the screen).The administrator must perform a “Refresh repository” action, also available
at the left of the screen.Create aVcWikientity and setrstas default extension.You should be able to create your wiki homepage through thewiki homepageaction on the left.Note that the Wiki pages are available at an URL which has the following
format:<base-url>/wiki/<wiki-name>/<page-name>
Package: cubicweb-web
CubicWeb Legacy Web moduleThis cube provides a dynamic view selection system. This system allows
semi-automatic XHTML/XML/JSON/text generation, based on context.
All this was once available in CubicWeb 3 as acubicweb.webmodule.This code is still maintained, however we no longer add new features.How to use it?This cube can be used like every other cubes. You just have to add it in your
application dependencies and/or add it when creating your instance.
However, you may need some configuration in order to have cubicweb views
working as expected. In pyramid.ini file (which is located in your instance
directory), you should disable default CubicWeb 4 html views by writing:cubicweb.content-negociation.html-default = yes
Package: cubicweb-wsme
Easily build a webservice API on top of a cubic web database.Once activated, the cube provides new controllers (their regid iswebservices) which respond on the rest path of entities, if the requests
matches one of the following condition:Content-Type == ‘application/json’Accept == ‘application/json’The following API is automatically provided for all the entities:HTTPactionGET /etype?filter=xxxreturn a list of entities matching the filterPOST /etypecreate a new entityGET /etype/1234return a particular entityPUT /etype/1234update an entityDELETE /etype/1234delete an entity
Package: cubids
CuBIDS: Curation of BIDSAboutCuration of BIDS, orCuBIDS, is a workflow and software package designed to facilitate
reproducible curation of neuroimagingBIDSdatasets.
CuBIDS breaks down BIDS dataset curation into four main components and addresses each one using
various command line programs complete with version control capabilities. These components are not necessarily linear but all are critical
in the process of preparing BIDS data for successful preprocessing and analysis pipeline runs.CuBIDS facilitates the validation of BIDS data.CuBIDS visualizes and summarizes the heterogeneity in a BIDS dataset.CuBIDS helps users test pipelines on the entire parameter space of a BIDS dataset.CuBIDS allows users to perform metadata-based quality control on their BIDS data.For full documentation, please visit ourReadTheDocsHistory0.1.0 (2020-10-07)First release on PyPI.
Package: cubids-bond-fork
BOnD: BIDS On DiskBOnDis designed to facilitate the curation and sanity-checking of BIDS
datasets that live on a hard drive. Its has many functions that help curators
follow the Three Steps of Curation. These steps areEnsure the data is valid BIDS.Detect potentially multipleparameter groupswithinkey groupsTest preprocessing pipelines on an example of eachparameter group.Step 1: Ensure the data is valid BIDSThe BOnD class has a call to a containerized version of the BIDS Validator. The
output of the BIDS validator is collected and converted to a convenient Python object.History0.1.0 (2020-10-07)First release on PyPI.
Package: cubieleds
# Cubieboard LED python moduleControl the green and blue LED on the Cubieboard with python.Tested with python 2.7+ and 3+### Enable LED support on the CubieboardIn order to use this module you need a Cubieboard (obviously), running somesort of linux. I have tested on Archlinux arm, but anything that run on theCubieboard should work.Then you need to activate the LEDs as [described here](http://linux-sunxi.org/Cubieboard/Programming/StatusLEDs).I also had to load the module:leds_sunxi### UsageThe module is pretty simpel. This is how it works:```python>>> import Cubie.leds# turn on the blue LED>>> Cubie.leds.on("blue")True# check status of blue LED>>> Cubie.leds.status("blue")1# Turn off blue LED>>> Cubie.leds.off("blue")True# check status again>>> Cubie.leds.status("blue")0# It is also possible to add a trigger, eg. the mmc0 trigger which will make# the LED blink on SD card activity>>> Cubie.leds.trigger("green", "mmc0")True>>> Cubie.leds.trigger_status("green")'mmc0'```
Package: cubi-isa-templates
CUBI ISA-Tab TemplatesThis repository containsCookiecutter-basedISA-Tabtemplates used atCUBI.Example of simple usage:fromcookiecutter.mainimportcookiecutterfromcubi_isa_templatesimportTEMPLATESisa_tpl=TEMPLATES["single_cell_rnaseq"]extra_context={"__output_dir":"template_dir"}cookiecutter(template=isa_tpl.path,extra_context=extra_context,output_dir="/template/path/",no_input=True)For proper command line usage, seecubi-tk.
Package: cubiscan
CUBISCANProvides an interface to cubiscan devices (https://cubiscan.com/).
These devices are used to measure and weigh objects.Usagefromcubiscan.cubiscanimportCubiScanobj=CubiScan(ip,port,timeout=timeout)obj.measure()FunctionsFollowing Functions of a Cubiscan are covered:Continuous measureDimension calibrationDimension unitsFactor ToggleLocation/City idMeasureScale calibrationTestUnitsWeight unitsZeroRelease HistoryUnreleasedfix issue with trailing null byte padding in answermore robust parsing of responsesadd logging0.0.2add TLS support0.0.1Inital Release
Package: cubix
CubixCubix is a simple, 100% python written, module for computing persistent homology in alternative way. Given a data cloudSofR^n, it builds a simplicial cubic complex coveringSand makes a filtration over this complex using a kernel density estimator (KDE) ofS.  For a formal definition of the method and the simplicial cubic homology implemented, we redirect the reader to the paper 'Filtraciones en homología persistente mediante estimadores kernel de densidad' ---writen in Spanish--- available on the Github repository.InstallYou can easily install Cubix viapip:pip install cubixBasic usageFirst of all, you must import the module:importcubixThe second step is choosing the data cloud to analyze. Cubix classCloudis designed to contain these objects. You can create your cloud importing points from a CSV file just like:X=cubix.Cloud(csv="input_file.csv")If you have yourNpoints ofR^n stored in a numpy array (let's call itarray) with shapen x Nyou can make aCloudwith them with:X=cubix.Cloud(data=array)Alternatively, Cubix has methods to generate random data clouds with some particular shapes: the spheresS⁰(inR),S¹(inR²) andS²(inR³) , the torusT²(inR³), the real projective spacesRP² (inR⁴), and de wedge sum of two spheresS¹vS¹(inR²). These are subclasses ofCloudso you can easily instantiate a 2000-point cloud withS²shape like:X=cubix.S2(center=(2,1,4),r=5,err=0.1,N=2000)For more information about the arguments accepted to instantiate this classes, please read the documentation of each one.Cloudclass have some useful methods for plotting (when possible) and exporting data. Take a look at those 3 methods:X.plot()X.kde_plot()X.export_to_csv("output.csv")Once you have your cloudX, you can calculate the persistence homology of it. You just have to create a variable of the classPersistentHomologythis way:h=X.persistent_homology()Of course, this will run the algorithm with default values. Arguments accepted bypersistence_homologyare:n- precision of the cubic complex covering the cloud (number of cubes per direction ofR^n). Default: 10.margin- parameter to make the cubic complex bigger than the space occupied by the cloud. Ex: withmargin=0.1the cubic complex will take a 10% more of space. Default: 0.1pruning- parameter to cut off the last (the most insignificant) cubes of the filtration in order to make the algorithm faster. Ex:pruning=0.9will keep only the 90% most significant cubes. Default: 0 (don't cut off).verbose- IfTrue, print by standard error the progress of the calculation. Default: False.Finally, you can see the results in three ways: a persistence diagram, a bar code or just explicitly printing out all born and death times:h.persitence_diagram()h.bar_code()h.detail()For more information, please check the documentation in the source code.This software has been developed as part of the Final Degree Project in Mathematics for Universitat Autònoma de Barcelona (UAB). If you are interested in filtrations using KDE's and you understand Spanish, please take a look at the paper 'Filtraciones en homología persistente mediante estimadores kernel de densidad' available on the Github repository.
Package: cuBNM
The cuBNM toolbox performs efficient simulation and optimization of biophysical network models (BNM) of the brain on GPUs.OverviewThe toolbox currently supports simulation of network nodes activity based on reduced Wong-Wang model with analytical-numerical feedback inhibition control. The Balloon-Windkessel model is used for calculation of simulated BOLD signals. It calculates goodness of fit of the simulated BOLD to the empirical BOLD based on functional connectivity (FC) and functional connectivity dynamics (FCD) matrices. The parameter optimization of the model can be done using grid search or evolutionary optimizers. Parallelization of the entire grid or each iteration of evolutionary optimizers is done at two levels: 1) simulations (across the GPU ‘blocks’), and 2) nodes (across each block’s ‘threads’). The toolbox additionally supports running the simulations on single- or multi-core CPUs, which will be used if no GPUs are detected or when requested by user (but the toolbox mainly focuses on GPUs).This is a simplified flowchart of the different components of the program written in Python, C++ and CUDA.Installationgit clone https://github.com/amnsbr/cuBNM.git
cd cuBNM && pip install .Installation requires Python (tested with 3.9) and g++. Currently Windows, Mac and non-Nvidia GPUs are not supported.GSLis another requirement which will be installed by the package (in~/.cuBNM/gsl) but it takes a rather long time and is only done iflibgsl.aandlibgslcblas.aare not found in"/usr/lib", "/lib", "/usr/local/lib", $LIBRARY_PATH, $LD_LIBRARY_PATH. If you have GSL on your system but it is installed elsewhere, please add thelibgsl.aandlibgslcblas.adirectories to$LIBRARY_PATH.UsageIn./examples/examples.pyyou can find some examples of running a single simulation (run_sims), grid search (run_grid) or CMAES optimization (run_cmaes_optimizer). More comprehensive documentations and examples will be added.
Package: cubo_harmonic
cubo-harmonicThis is a template repository for Python projects that use Poetry for their dependency management.Github repository:https://github.com/csaybar/cubo-harmonic/Documentationhttps://csaybar.github.io/cubo-harmonic/Getting started with your projectFirst, create a repository on GitHub with the same name as this project, and then run the following commands:gitinit-bmain
gitadd.
gitcommit-m"init commit"gitremoteaddorigingit@github.com:csaybar/cubo-harmonic.git
gitpush-uoriginmainFinally, install the environment and the pre-commit hooks withmakeinstallYou are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.To finalize the set-up for publishing to PyPi or Artifactory, seehere.
For activating the automatic documentation with MkDocs, seehere.
To enable the code coverage reports, seehere.Releasing a new versionCreate an API Token onPypi.Add the API Token to your projects secrets with the namePYPI_TOKENby visitingthis page.Create anew releaseon Github.Create a new tag in the form*.*.*.For more details, seehere.Repository initiated withfpgmaas/cookiecutter-poetry.
Package: cuboid-sphere
SetupPre Requirements:Install Docker:LinkInstall Docker Compose:pip install docker-composeSetup Docker:# Build dockerdocker-composeup-d# OR# Pull prebuilt dockerdockerpullbendang/cuboid_sphere&&docker-composeup-dInstall package:pipinstallcuboid-sphereTestfromcuboid_sphereimportcall_2d,call_3d,display_2d_result,display_3d_result,save_point_cloud# if docker hosted locally# ip = 1.2.3.4ip="localhost"# Port based on docker compose settingsport="8888"# Task 1# hdf5_path = "/PATH/TO/HDF5_FILE.hdf5"hdf5_path='test_data/cuboid-sphere.hdf5'result=call_3d(hdf5_path,ip=ip,port=port)save_point_cloud(result["point_cloud"],"/PATH/TO/SAVE.hdf5")# saving Point Clouddisplay_3d_result(hdf5_path,result)# display volume, surface area, centroid and depth map# Task 2# image_path = "/PATH/TO/IMAGE.png"image_path="test_data/cuboid-sphere.png"result=call_2d(image_path,ip=ip,port=port)display_2d_result(image_path,result)
Package: cuboxgpt
cuboxGPTUse GPT to help users quickly search/chat with your large cubox dataset.UseInstall the package.pipinstallcuboxGPTExport the cubox dataset as html file.Call the command line tool# set openai api keyEXPORTOPENAI_API_KEY=<youropenaiapikey># import all cubox bookmarks and downald all web contents.# Note that the cli will output links that are failed to download and links that have not enough contents.cuboxgptimport-data<cubox_export.htmlfilelocation># Init the vector database. Put all downloaded web contents to the vector database and generate embeddings. Save the database in db/ folder.cuboxgptinit-database# chat/seach with the datasetcuboxgptsearch<query>Developmentvenv./venvsource./venv/bin/activate
pipinstall--editable.cuboxGPT.pyhas all comand line tools implementation.chatFromDB.pyreads from the database and implement the query function.webPraser.pytakes responsibility to parse the html file and download the web contents.db.pygenerate embeddings and save web contents to the database.pyproject.tomlcontains ruff lint configuration.RoadmapGoal: Enhance the search experience and easily keep datasets up to date.Better CRUD on database. Users can update/delete single ducoments in the database.Seach document with custom filter on metadata.Better parsing rule for certain websites like Twitter, Youtube with Chinese characters, WeixinBetter updating experience if user input a new cubox export file.Pagination for search results.Analyze user's query to better hit keywords.For links failed to download, retry with SeleumSupport multi-threading for downloading web contents.Better title by supporting open graph meta tags
Package: cuby
Cuby⚠️ work in progress ⚠️Cuby is a lightweight metric store with minimal abstractions.
It enables fetching metrics, filtered by dimensions, by parsing metric queries based on a data model.
The data model defines dimensions and metrics similar to Looker and supports joins on primary keys.
The data model is defined in YAML files.
The package generates a SQL query that you can use to fetch your results.InstallationpipinstallcubyUsageCuby can be used both as a Python library and through its command line interface (CLI).As a Python LibraryYou can import theload_cubes, andgenerate_sql_queryfunctions from their respective modules to use in your Python code.CLI CommandsTo list all cubes:cubylist_cubesTo list all metrics for a cube:cubylist_metrics<cube_name>To execute a query on a model:cubyquery"<query_json>"Thequerycommand expects a JSON string as its argument. Here's an example:cubyquery"{'fields': ['orders.booking_date', 'annual_recurring_revenue', 'churned_revenue'], 'filter': {'country_id': '45', 'product_brand': 'BIG'}, 'sorts': ['booking_date'], 'limit': 300}"Defining ModelsModels are defined in YAML files with the following structure:name:<cube_name>table:<table_path>dimensions:-name:<dimension_name>sql:<sql_expression>...metrics:-name:<measure_name>sql:<sql_expression>...Basically all SQL databases are supported: PostgreSQL, Snowflake, Redshift, BigQuery, Databricks SQL, Druid, ...ContributingIf you have suggestions for how Cuby could be improved, or want to report a bug, open an issue!
We'd love all and any contributions.